import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AuthApi;

import java.io.File;
import java.util.*;

public class AuthApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        AuthApi apiInstance = new AuthApi();
        AuthChangePasswordRequest authChangePasswordRequest = ; // AuthChangePasswordRequest | 

        try {
            auth_logout_200_response result = apiInstance.authChangePassword(authChangePasswordRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AuthApi#authChangePassword");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final AuthChangePasswordRequest authChangePasswordRequest = new AuthChangePasswordRequest(); // AuthChangePasswordRequest | 

try {
    final result = await api_instance.authChangePassword(authChangePasswordRequest);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->authChangePassword: $e\n');
}

import org.openapitools.client.api.AuthApi;

public class AuthApiExample {
    public static void main(String[] args) {
        AuthApi apiInstance = new AuthApi();
        AuthChangePasswordRequest authChangePasswordRequest = ; // AuthChangePasswordRequest | 

        try {
            auth_logout_200_response result = apiInstance.authChangePassword(authChangePasswordRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AuthApi#authChangePassword");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
AuthApi *apiInstance = [[AuthApi alloc] init];
AuthChangePasswordRequest *authChangePasswordRequest = ; // 

// Change password
[apiInstance authChangePasswordWith:authChangePasswordRequest
              completionHandler: ^(auth_logout_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.AuthApi()
var authChangePasswordRequest = ; // {AuthChangePasswordRequest} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.authChangePassword(authChangePasswordRequest, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class authChangePasswordExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new AuthApi();
            var authChangePasswordRequest = new AuthChangePasswordRequest(); // AuthChangePasswordRequest | 

            try {
                // Change password
                auth_logout_200_response result = apiInstance.authChangePassword(authChangePasswordRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling AuthApi.authChangePassword: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AuthApi();
$authChangePasswordRequest = ; // AuthChangePasswordRequest | 

try {
    $result = $api_instance->authChangePassword($authChangePasswordRequest);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling AuthApi->authChangePassword: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::AuthApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AuthApi->new();
my $authChangePasswordRequest = WWW::OPenAPIClient::Object::AuthChangePasswordRequest->new(); # AuthChangePasswordRequest | 

eval {
    my $result = $api_instance->authChangePassword(authChangePasswordRequest => $authChangePasswordRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AuthApi->authChangePassword: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.AuthApi()
authChangePasswordRequest =  # AuthChangePasswordRequest | 

try:
    # Change password
    api_response = api_instance.auth_change_password(authChangePasswordRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AuthApi->authChangePassword: %s\n" % e)

extern crate AuthApi;

pub fn main() {
    let authChangePasswordRequest = ; // AuthChangePasswordRequest

    let mut context = AuthApi::Context::default();
    let result = client.authChangePassword(authChangePasswordRequest, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AuthApi;

import java.io.File;
import java.util.*;

public class AuthApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        AuthApi apiInstance = new AuthApi();
        LoginRequest loginRequest = ; // LoginRequest | 

        try {
            auth_login_200_response result = apiInstance.authLogin(loginRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AuthApi#authLogin");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final LoginRequest loginRequest = new LoginRequest(); // LoginRequest | 

try {
    final result = await api_instance.authLogin(loginRequest);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->authLogin: $e\n');
}

import org.openapitools.client.api.AuthApi;

public class AuthApiExample {
    public static void main(String[] args) {
        AuthApi apiInstance = new AuthApi();
        LoginRequest loginRequest = ; // LoginRequest | 

        try {
            auth_login_200_response result = apiInstance.authLogin(loginRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AuthApi#authLogin");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
AuthApi *apiInstance = [[AuthApi alloc] init];
LoginRequest *loginRequest = ; // 

// User login
[apiInstance authLoginWith:loginRequest
              completionHandler: ^(auth_login_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.AuthApi()
var loginRequest = ; // {LoginRequest} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.authLogin(loginRequest, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class authLoginExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new AuthApi();
            var loginRequest = new LoginRequest(); // LoginRequest | 

            try {
                // User login
                auth_login_200_response result = apiInstance.authLogin(loginRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling AuthApi.authLogin: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AuthApi();
$loginRequest = ; // LoginRequest | 

try {
    $result = $api_instance->authLogin($loginRequest);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling AuthApi->authLogin: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::AuthApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AuthApi->new();
my $loginRequest = WWW::OPenAPIClient::Object::LoginRequest->new(); # LoginRequest | 

eval {
    my $result = $api_instance->authLogin(loginRequest => $loginRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AuthApi->authLogin: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.AuthApi()
loginRequest =  # LoginRequest | 

try:
    # User login
    api_response = api_instance.auth_login(loginRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AuthApi->authLogin: %s\n" % e)

extern crate AuthApi;

pub fn main() {
    let loginRequest = ; // LoginRequest

    let mut context = AuthApi::Context::default();
    let result = client.authLogin(loginRequest, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AuthApi;

import java.io.File;
import java.util.*;

public class AuthApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        AuthApi apiInstance = new AuthApi();

        try {
            auth_logout_200_response result = apiInstance.authLogout();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AuthApi#authLogout");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


try {
    final result = await api_instance.authLogout();
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->authLogout: $e\n');
}

import org.openapitools.client.api.AuthApi;

public class AuthApiExample {
    public static void main(String[] args) {
        AuthApi apiInstance = new AuthApi();

        try {
            auth_logout_200_response result = apiInstance.authLogout();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AuthApi#authLogout");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
AuthApi *apiInstance = [[AuthApi alloc] init];

// User logout
[apiInstance authLogoutWithCompletionHandler: 
              ^(auth_logout_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.AuthApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.authLogout(callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class authLogoutExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new AuthApi();

            try {
                // User logout
                auth_logout_200_response result = apiInstance.authLogout();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling AuthApi.authLogout: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AuthApi();

try {
    $result = $api_instance->authLogout();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling AuthApi->authLogout: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::AuthApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AuthApi->new();

eval {
    my $result = $api_instance->authLogout();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AuthApi->authLogout: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.AuthApi()

try:
    # User logout
    api_response = api_instance.auth_logout()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AuthApi->authLogout: %s\n" % e)

extern crate AuthApi;

pub fn main() {

    let mut context = AuthApi::Context::default();
    let result = client.authLogout(&context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AuthApi;

import java.io.File;
import java.util.*;

public class AuthApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        AuthApi apiInstance = new AuthApi();

        try {
            auth_me_200_response result = apiInstance.authMe();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AuthApi#authMe");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


try {
    final result = await api_instance.authMe();
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->authMe: $e\n');
}

import org.openapitools.client.api.AuthApi;

public class AuthApiExample {
    public static void main(String[] args) {
        AuthApi apiInstance = new AuthApi();

        try {
            auth_me_200_response result = apiInstance.authMe();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AuthApi#authMe");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
AuthApi *apiInstance = [[AuthApi alloc] init];

// Get current user
[apiInstance authMeWithCompletionHandler: 
              ^(auth_me_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.AuthApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.authMe(callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class authMeExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new AuthApi();

            try {
                // Get current user
                auth_me_200_response result = apiInstance.authMe();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling AuthApi.authMe: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AuthApi();

try {
    $result = $api_instance->authMe();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling AuthApi->authMe: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::AuthApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AuthApi->new();

eval {
    my $result = $api_instance->authMe();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AuthApi->authMe: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.AuthApi()

try:
    # Get current user
    api_response = api_instance.auth_me()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AuthApi->authMe: %s\n" % e)

extern crate AuthApi;

pub fn main() {

    let mut context = AuthApi::Context::default();
    let result = client.authMe(&context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AuthApi;

import java.io.File;
import java.util.*;

public class AuthApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        AuthApi apiInstance = new AuthApi();

        try {
            auth_login_200_response result = apiInstance.authRefresh();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AuthApi#authRefresh");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


try {
    final result = await api_instance.authRefresh();
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->authRefresh: $e\n');
}

import org.openapitools.client.api.AuthApi;

public class AuthApiExample {
    public static void main(String[] args) {
        AuthApi apiInstance = new AuthApi();

        try {
            auth_login_200_response result = apiInstance.authRefresh();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AuthApi#authRefresh");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
AuthApi *apiInstance = [[AuthApi alloc] init];

// Refresh session
[apiInstance authRefreshWithCompletionHandler: 
              ^(auth_login_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.AuthApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.authRefresh(callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class authRefreshExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new AuthApi();

            try {
                // Refresh session
                auth_login_200_response result = apiInstance.authRefresh();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling AuthApi.authRefresh: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AuthApi();

try {
    $result = $api_instance->authRefresh();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling AuthApi->authRefresh: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::AuthApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AuthApi->new();

eval {
    my $result = $api_instance->authRefresh();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AuthApi->authRefresh: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.AuthApi()

try:
    # Refresh session
    api_response = api_instance.auth_refresh()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AuthApi->authRefresh: %s\n" % e)

extern crate AuthApi;

pub fn main() {

    let mut context = AuthApi::Context::default();
    let result = client.authRefresh(&context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.CampaignsApi;

import java.io.File;
import java.util.*;

public class CampaignsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        CampaignsApi apiInstance = new CampaignsApi();
        BulkResourceAllocationRequest bulkResourceAllocationRequest = ; // BulkResourceAllocationRequest | 

        try {
            allocateBulkResources_200_response result = apiInstance.allocateBulkResources(bulkResourceAllocationRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#allocateBulkResources");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final BulkResourceAllocationRequest bulkResourceAllocationRequest = new BulkResourceAllocationRequest(); // BulkResourceAllocationRequest | 

try {
    final result = await api_instance.allocateBulkResources(bulkResourceAllocationRequest);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->allocateBulkResources: $e\n');
}

import org.openapitools.client.api.CampaignsApi;

public class CampaignsApiExample {
    public static void main(String[] args) {
        CampaignsApi apiInstance = new CampaignsApi();
        BulkResourceAllocationRequest bulkResourceAllocationRequest = ; // BulkResourceAllocationRequest | 

        try {
            allocateBulkResources_200_response result = apiInstance.allocateBulkResources(bulkResourceAllocationRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#allocateBulkResources");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
CampaignsApi *apiInstance = [[CampaignsApi alloc] init];
BulkResourceAllocationRequest *bulkResourceAllocationRequest = ; // 

// Allocate bulk operation resources
[apiInstance allocateBulkResourcesWith:bulkResourceAllocationRequest
              completionHandler: ^(allocateBulkResources_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.CampaignsApi()
var bulkResourceAllocationRequest = ; // {BulkResourceAllocationRequest} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.allocateBulkResources(bulkResourceAllocationRequest, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class allocateBulkResourcesExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new CampaignsApi();
            var bulkResourceAllocationRequest = new BulkResourceAllocationRequest(); // BulkResourceAllocationRequest | 

            try {
                // Allocate bulk operation resources
                allocateBulkResources_200_response result = apiInstance.allocateBulkResources(bulkResourceAllocationRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling CampaignsApi.allocateBulkResources: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CampaignsApi();
$bulkResourceAllocationRequest = ; // BulkResourceAllocationRequest | 

try {
    $result = $api_instance->allocateBulkResources($bulkResourceAllocationRequest);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling CampaignsApi->allocateBulkResources: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::CampaignsApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CampaignsApi->new();
my $bulkResourceAllocationRequest = WWW::OPenAPIClient::Object::BulkResourceAllocationRequest->new(); # BulkResourceAllocationRequest | 

eval {
    my $result = $api_instance->allocateBulkResources(bulkResourceAllocationRequest => $bulkResourceAllocationRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling CampaignsApi->allocateBulkResources: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.CampaignsApi()
bulkResourceAllocationRequest =  # BulkResourceAllocationRequest | 

try:
    # Allocate bulk operation resources
    api_response = api_instance.allocate_bulk_resources(bulkResourceAllocationRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CampaignsApi->allocateBulkResources: %s\n" % e)

extern crate CampaignsApi;

pub fn main() {
    let bulkResourceAllocationRequest = ; // BulkResourceAllocationRequest

    let mut context = CampaignsApi::Context::default();
    let result = client.allocateBulkResources(bulkResourceAllocationRequest, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.CampaignsApi;

import java.io.File;
import java.util.*;

public class CampaignsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        CampaignsApi apiInstance = new CampaignsApi();
        BulkAnalyticsRequest bulkAnalyticsRequest = ; // BulkAnalyticsRequest | 

        try {
            bulkAnalyzeDomains_200_response result = apiInstance.bulkAnalyzeDomains(bulkAnalyticsRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#bulkAnalyzeDomains");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final BulkAnalyticsRequest bulkAnalyticsRequest = new BulkAnalyticsRequest(); // BulkAnalyticsRequest | 

try {
    final result = await api_instance.bulkAnalyzeDomains(bulkAnalyticsRequest);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->bulkAnalyzeDomains: $e\n');
}

import org.openapitools.client.api.CampaignsApi;

public class CampaignsApiExample {
    public static void main(String[] args) {
        CampaignsApi apiInstance = new CampaignsApi();
        BulkAnalyticsRequest bulkAnalyticsRequest = ; // BulkAnalyticsRequest | 

        try {
            bulkAnalyzeDomains_200_response result = apiInstance.bulkAnalyzeDomains(bulkAnalyticsRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#bulkAnalyzeDomains");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
CampaignsApi *apiInstance = [[CampaignsApi alloc] init];
BulkAnalyticsRequest *bulkAnalyticsRequest = ; // 

// Bulk domain analysis
[apiInstance bulkAnalyzeDomainsWith:bulkAnalyticsRequest
              completionHandler: ^(bulkAnalyzeDomains_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.CampaignsApi()
var bulkAnalyticsRequest = ; // {BulkAnalyticsRequest} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.bulkAnalyzeDomains(bulkAnalyticsRequest, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class bulkAnalyzeDomainsExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new CampaignsApi();
            var bulkAnalyticsRequest = new BulkAnalyticsRequest(); // BulkAnalyticsRequest | 

            try {
                // Bulk domain analysis
                bulkAnalyzeDomains_200_response result = apiInstance.bulkAnalyzeDomains(bulkAnalyticsRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling CampaignsApi.bulkAnalyzeDomains: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CampaignsApi();
$bulkAnalyticsRequest = ; // BulkAnalyticsRequest | 

try {
    $result = $api_instance->bulkAnalyzeDomains($bulkAnalyticsRequest);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling CampaignsApi->bulkAnalyzeDomains: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::CampaignsApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CampaignsApi->new();
my $bulkAnalyticsRequest = WWW::OPenAPIClient::Object::BulkAnalyticsRequest->new(); # BulkAnalyticsRequest | 

eval {
    my $result = $api_instance->bulkAnalyzeDomains(bulkAnalyticsRequest => $bulkAnalyticsRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling CampaignsApi->bulkAnalyzeDomains: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.CampaignsApi()
bulkAnalyticsRequest =  # BulkAnalyticsRequest | 

try:
    # Bulk domain analysis
    api_response = api_instance.bulk_analyze_domains(bulkAnalyticsRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CampaignsApi->bulkAnalyzeDomains: %s\n" % e)

extern crate CampaignsApi;

pub fn main() {
    let bulkAnalyticsRequest = ; // BulkAnalyticsRequest

    let mut context = CampaignsApi::Context::default();
    let result = client.bulkAnalyzeDomains(bulkAnalyticsRequest, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.CampaignsApi;

import java.io.File;
import java.util.*;

public class CampaignsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        CampaignsApi apiInstance = new CampaignsApi();
        BulkDomainGenerationRequest bulkDomainGenerationRequest = ; // BulkDomainGenerationRequest | 

        try {
            bulkGenerateDomains_200_response result = apiInstance.bulkGenerateDomains(bulkDomainGenerationRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#bulkGenerateDomains");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final BulkDomainGenerationRequest bulkDomainGenerationRequest = new BulkDomainGenerationRequest(); // BulkDomainGenerationRequest | 

try {
    final result = await api_instance.bulkGenerateDomains(bulkDomainGenerationRequest);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->bulkGenerateDomains: $e\n');
}

import org.openapitools.client.api.CampaignsApi;

public class CampaignsApiExample {
    public static void main(String[] args) {
        CampaignsApi apiInstance = new CampaignsApi();
        BulkDomainGenerationRequest bulkDomainGenerationRequest = ; // BulkDomainGenerationRequest | 

        try {
            bulkGenerateDomains_200_response result = apiInstance.bulkGenerateDomains(bulkDomainGenerationRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#bulkGenerateDomains");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
CampaignsApi *apiInstance = [[CampaignsApi alloc] init];
BulkDomainGenerationRequest *bulkDomainGenerationRequest = ; // 

// Bulk domain generation
[apiInstance bulkGenerateDomainsWith:bulkDomainGenerationRequest
              completionHandler: ^(bulkGenerateDomains_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.CampaignsApi()
var bulkDomainGenerationRequest = ; // {BulkDomainGenerationRequest} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.bulkGenerateDomains(bulkDomainGenerationRequest, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class bulkGenerateDomainsExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new CampaignsApi();
            var bulkDomainGenerationRequest = new BulkDomainGenerationRequest(); // BulkDomainGenerationRequest | 

            try {
                // Bulk domain generation
                bulkGenerateDomains_200_response result = apiInstance.bulkGenerateDomains(bulkDomainGenerationRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling CampaignsApi.bulkGenerateDomains: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CampaignsApi();
$bulkDomainGenerationRequest = ; // BulkDomainGenerationRequest | 

try {
    $result = $api_instance->bulkGenerateDomains($bulkDomainGenerationRequest);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling CampaignsApi->bulkGenerateDomains: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::CampaignsApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CampaignsApi->new();
my $bulkDomainGenerationRequest = WWW::OPenAPIClient::Object::BulkDomainGenerationRequest->new(); # BulkDomainGenerationRequest | 

eval {
    my $result = $api_instance->bulkGenerateDomains(bulkDomainGenerationRequest => $bulkDomainGenerationRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling CampaignsApi->bulkGenerateDomains: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.CampaignsApi()
bulkDomainGenerationRequest =  # BulkDomainGenerationRequest | 

try:
    # Bulk domain generation
    api_response = api_instance.bulk_generate_domains(bulkDomainGenerationRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CampaignsApi->bulkGenerateDomains: %s\n" % e)

extern crate CampaignsApi;

pub fn main() {
    let bulkDomainGenerationRequest = ; // BulkDomainGenerationRequest

    let mut context = CampaignsApi::Context::default();
    let result = client.bulkGenerateDomains(bulkDomainGenerationRequest, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.CampaignsApi;

import java.io.File;
import java.util.*;

public class CampaignsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        CampaignsApi apiInstance = new CampaignsApi();
        BulkDNSValidationRequest bulkDNSValidationRequest = ; // BulkDNSValidationRequest | 

        try {
            bulkValidateDNS_200_response result = apiInstance.bulkValidateDNS(bulkDNSValidationRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#bulkValidateDNS");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final BulkDNSValidationRequest bulkDNSValidationRequest = new BulkDNSValidationRequest(); // BulkDNSValidationRequest | 

try {
    final result = await api_instance.bulkValidateDNS(bulkDNSValidationRequest);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->bulkValidateDNS: $e\n');
}

import org.openapitools.client.api.CampaignsApi;

public class CampaignsApiExample {
    public static void main(String[] args) {
        CampaignsApi apiInstance = new CampaignsApi();
        BulkDNSValidationRequest bulkDNSValidationRequest = ; // BulkDNSValidationRequest | 

        try {
            bulkValidateDNS_200_response result = apiInstance.bulkValidateDNS(bulkDNSValidationRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#bulkValidateDNS");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
CampaignsApi *apiInstance = [[CampaignsApi alloc] init];
BulkDNSValidationRequest *bulkDNSValidationRequest = ; // 

// Bulk DNS validation
[apiInstance bulkValidateDNSWith:bulkDNSValidationRequest
              completionHandler: ^(bulkValidateDNS_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.CampaignsApi()
var bulkDNSValidationRequest = ; // {BulkDNSValidationRequest} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.bulkValidateDNS(bulkDNSValidationRequest, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class bulkValidateDNSExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new CampaignsApi();
            var bulkDNSValidationRequest = new BulkDNSValidationRequest(); // BulkDNSValidationRequest | 

            try {
                // Bulk DNS validation
                bulkValidateDNS_200_response result = apiInstance.bulkValidateDNS(bulkDNSValidationRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling CampaignsApi.bulkValidateDNS: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CampaignsApi();
$bulkDNSValidationRequest = ; // BulkDNSValidationRequest | 

try {
    $result = $api_instance->bulkValidateDNS($bulkDNSValidationRequest);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling CampaignsApi->bulkValidateDNS: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::CampaignsApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CampaignsApi->new();
my $bulkDNSValidationRequest = WWW::OPenAPIClient::Object::BulkDNSValidationRequest->new(); # BulkDNSValidationRequest | 

eval {
    my $result = $api_instance->bulkValidateDNS(bulkDNSValidationRequest => $bulkDNSValidationRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling CampaignsApi->bulkValidateDNS: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.CampaignsApi()
bulkDNSValidationRequest =  # BulkDNSValidationRequest | 

try:
    # Bulk DNS validation
    api_response = api_instance.bulk_validate_dns(bulkDNSValidationRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CampaignsApi->bulkValidateDNS: %s\n" % e)

extern crate CampaignsApi;

pub fn main() {
    let bulkDNSValidationRequest = ; // BulkDNSValidationRequest

    let mut context = CampaignsApi::Context::default();
    let result = client.bulkValidateDNS(bulkDNSValidationRequest, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.CampaignsApi;

import java.io.File;
import java.util.*;

public class CampaignsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        CampaignsApi apiInstance = new CampaignsApi();
        BulkHTTPValidationRequest bulkHTTPValidationRequest = ; // BulkHTTPValidationRequest | 

        try {
            bulkValidateDNS_200_response result = apiInstance.bulkValidateHTTP(bulkHTTPValidationRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#bulkValidateHTTP");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final BulkHTTPValidationRequest bulkHTTPValidationRequest = new BulkHTTPValidationRequest(); // BulkHTTPValidationRequest | 

try {
    final result = await api_instance.bulkValidateHTTP(bulkHTTPValidationRequest);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->bulkValidateHTTP: $e\n');
}

import org.openapitools.client.api.CampaignsApi;

public class CampaignsApiExample {
    public static void main(String[] args) {
        CampaignsApi apiInstance = new CampaignsApi();
        BulkHTTPValidationRequest bulkHTTPValidationRequest = ; // BulkHTTPValidationRequest | 

        try {
            bulkValidateDNS_200_response result = apiInstance.bulkValidateHTTP(bulkHTTPValidationRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#bulkValidateHTTP");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
CampaignsApi *apiInstance = [[CampaignsApi alloc] init];
BulkHTTPValidationRequest *bulkHTTPValidationRequest = ; // 

// Bulk HTTP validation
[apiInstance bulkValidateHTTPWith:bulkHTTPValidationRequest
              completionHandler: ^(bulkValidateDNS_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.CampaignsApi()
var bulkHTTPValidationRequest = ; // {BulkHTTPValidationRequest} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.bulkValidateHTTP(bulkHTTPValidationRequest, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class bulkValidateHTTPExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new CampaignsApi();
            var bulkHTTPValidationRequest = new BulkHTTPValidationRequest(); // BulkHTTPValidationRequest | 

            try {
                // Bulk HTTP validation
                bulkValidateDNS_200_response result = apiInstance.bulkValidateHTTP(bulkHTTPValidationRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling CampaignsApi.bulkValidateHTTP: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CampaignsApi();
$bulkHTTPValidationRequest = ; // BulkHTTPValidationRequest | 

try {
    $result = $api_instance->bulkValidateHTTP($bulkHTTPValidationRequest);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling CampaignsApi->bulkValidateHTTP: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::CampaignsApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CampaignsApi->new();
my $bulkHTTPValidationRequest = WWW::OPenAPIClient::Object::BulkHTTPValidationRequest->new(); # BulkHTTPValidationRequest | 

eval {
    my $result = $api_instance->bulkValidateHTTP(bulkHTTPValidationRequest => $bulkHTTPValidationRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling CampaignsApi->bulkValidateHTTP: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.CampaignsApi()
bulkHTTPValidationRequest =  # BulkHTTPValidationRequest | 

try:
    # Bulk HTTP validation
    api_response = api_instance.bulk_validate_http(bulkHTTPValidationRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CampaignsApi->bulkValidateHTTP: %s\n" % e)

extern crate CampaignsApi;

pub fn main() {
    let bulkHTTPValidationRequest = ; // BulkHTTPValidationRequest

    let mut context = CampaignsApi::Context::default();
    let result = client.bulkValidateHTTP(bulkHTTPValidationRequest, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.CampaignsApi;

import java.io.File;
import java.util.*;

public class CampaignsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        CampaignsApi apiInstance = new CampaignsApi();

        try {
            campaigns_bulk_operations_list_200_response result = apiInstance.campaignsBulkOperationsList();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#campaignsBulkOperationsList");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


try {
    final result = await api_instance.campaignsBulkOperationsList();
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->campaignsBulkOperationsList: $e\n');
}

import org.openapitools.client.api.CampaignsApi;

public class CampaignsApiExample {
    public static void main(String[] args) {
        CampaignsApi apiInstance = new CampaignsApi();

        try {
            campaigns_bulk_operations_list_200_response result = apiInstance.campaignsBulkOperationsList();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#campaignsBulkOperationsList");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
CampaignsApi *apiInstance = [[CampaignsApi alloc] init];

// List bulk operations
[apiInstance campaignsBulkOperationsListWithCompletionHandler: 
              ^(campaigns_bulk_operations_list_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.CampaignsApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.campaignsBulkOperationsList(callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class campaignsBulkOperationsListExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new CampaignsApi();

            try {
                // List bulk operations
                campaigns_bulk_operations_list_200_response result = apiInstance.campaignsBulkOperationsList();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling CampaignsApi.campaignsBulkOperationsList: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CampaignsApi();

try {
    $result = $api_instance->campaignsBulkOperationsList();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling CampaignsApi->campaignsBulkOperationsList: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::CampaignsApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CampaignsApi->new();

eval {
    my $result = $api_instance->campaignsBulkOperationsList();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling CampaignsApi->campaignsBulkOperationsList: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.CampaignsApi()

try:
    # List bulk operations
    api_response = api_instance.campaigns_bulk_operations_list()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CampaignsApi->campaignsBulkOperationsList: %s\n" % e)

extern crate CampaignsApi;

pub fn main() {

    let mut context = CampaignsApi::Context::default();
    let result = client.campaignsBulkOperationsList(&context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.CampaignsApi;

import java.io.File;
import java.util.*;

public class CampaignsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        CampaignsApi apiInstance = new CampaignsApi();
        CreateCampaignRequest createCampaignRequest = ; // CreateCampaignRequest | 

        try {
            campaigns_create_201_response result = apiInstance.campaignsCreate(createCampaignRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#campaignsCreate");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final CreateCampaignRequest createCampaignRequest = new CreateCampaignRequest(); // CreateCampaignRequest | 

try {
    final result = await api_instance.campaignsCreate(createCampaignRequest);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->campaignsCreate: $e\n');
}

import org.openapitools.client.api.CampaignsApi;

public class CampaignsApiExample {
    public static void main(String[] args) {
        CampaignsApi apiInstance = new CampaignsApi();
        CreateCampaignRequest createCampaignRequest = ; // CreateCampaignRequest | 

        try {
            campaigns_create_201_response result = apiInstance.campaignsCreate(createCampaignRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#campaignsCreate");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
CampaignsApi *apiInstance = [[CampaignsApi alloc] init];
CreateCampaignRequest *createCampaignRequest = ; // 

// Create campaign
[apiInstance campaignsCreateWith:createCampaignRequest
              completionHandler: ^(campaigns_create_201_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.CampaignsApi()
var createCampaignRequest = ; // {CreateCampaignRequest} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.campaignsCreate(createCampaignRequest, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class campaignsCreateExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new CampaignsApi();
            var createCampaignRequest = new CreateCampaignRequest(); // CreateCampaignRequest | 

            try {
                // Create campaign
                campaigns_create_201_response result = apiInstance.campaignsCreate(createCampaignRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling CampaignsApi.campaignsCreate: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CampaignsApi();
$createCampaignRequest = ; // CreateCampaignRequest | 

try {
    $result = $api_instance->campaignsCreate($createCampaignRequest);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling CampaignsApi->campaignsCreate: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::CampaignsApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CampaignsApi->new();
my $createCampaignRequest = WWW::OPenAPIClient::Object::CreateCampaignRequest->new(); # CreateCampaignRequest | 

eval {
    my $result = $api_instance->campaignsCreate(createCampaignRequest => $createCampaignRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling CampaignsApi->campaignsCreate: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.CampaignsApi()
createCampaignRequest =  # CreateCampaignRequest | 

try:
    # Create campaign
    api_response = api_instance.campaigns_create(createCampaignRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CampaignsApi->campaignsCreate: %s\n" % e)

extern crate CampaignsApi;

pub fn main() {
    let createCampaignRequest = ; // CreateCampaignRequest

    let mut context = CampaignsApi::Context::default();
    let result = client.campaignsCreate(createCampaignRequest, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.CampaignsApi;

import java.io.File;
import java.util.*;

public class CampaignsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        CampaignsApi apiInstance = new CampaignsApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            apiInstance.campaignsDelete(campaignId);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#campaignsDelete");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UUID campaignId = new UUID(); // UUID | 

try {
    final result = await api_instance.campaignsDelete(campaignId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->campaignsDelete: $e\n');
}

import org.openapitools.client.api.CampaignsApi;

public class CampaignsApiExample {
    public static void main(String[] args) {
        CampaignsApi apiInstance = new CampaignsApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            apiInstance.campaignsDelete(campaignId);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#campaignsDelete");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
CampaignsApi *apiInstance = [[CampaignsApi alloc] init];
UUID *campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (default to null)

// Delete campaign
[apiInstance campaignsDeleteWith:campaignId
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.CampaignsApi()
var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.campaignsDelete(campaignId, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class campaignsDeleteExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new CampaignsApi();
            var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (default to null)

            try {
                // Delete campaign
                apiInstance.campaignsDelete(campaignId);
            } catch (Exception e) {
                Debug.Print("Exception when calling CampaignsApi.campaignsDelete: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CampaignsApi();
$campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

try {
    $api_instance->campaignsDelete($campaignId);
} catch (Exception $e) {
    echo 'Exception when calling CampaignsApi->campaignsDelete: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::CampaignsApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CampaignsApi->new();
my $campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 

eval {
    $api_instance->campaignsDelete(campaignId => $campaignId);
};
if ($@) {
    warn "Exception when calling CampaignsApi->campaignsDelete: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.CampaignsApi()
campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (default to null)

try:
    # Delete campaign
    api_instance.campaigns_delete(campaignId)
except ApiException as e:
    print("Exception when calling CampaignsApi->campaignsDelete: %s\n" % e)

extern crate CampaignsApi;

pub fn main() {
    let campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID

    let mut context = CampaignsApi::Context::default();
    let result = client.campaignsDelete(campaignId, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.CampaignsApi;

import java.io.File;
import java.util.*;

public class CampaignsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        CampaignsApi apiInstance = new CampaignsApi();
        PatternOffsetRequest patternOffsetRequest = ; // PatternOffsetRequest | 

        try {
            campaigns_domain_generation_pattern_offset_200_response result = apiInstance.campaignsDomainGenerationPatternOffset(patternOffsetRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#campaignsDomainGenerationPatternOffset");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final PatternOffsetRequest patternOffsetRequest = new PatternOffsetRequest(); // PatternOffsetRequest | 

try {
    final result = await api_instance.campaignsDomainGenerationPatternOffset(patternOffsetRequest);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->campaignsDomainGenerationPatternOffset: $e\n');
}

import org.openapitools.client.api.CampaignsApi;

public class CampaignsApiExample {
    public static void main(String[] args) {
        CampaignsApi apiInstance = new CampaignsApi();
        PatternOffsetRequest patternOffsetRequest = ; // PatternOffsetRequest | 

        try {
            campaigns_domain_generation_pattern_offset_200_response result = apiInstance.campaignsDomainGenerationPatternOffset(patternOffsetRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#campaignsDomainGenerationPatternOffset");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
CampaignsApi *apiInstance = [[CampaignsApi alloc] init];
PatternOffsetRequest *patternOffsetRequest = ; // 

// Get current global pattern offset for domain generation config
[apiInstance campaignsDomainGenerationPatternOffsetWith:patternOffsetRequest
              completionHandler: ^(campaigns_domain_generation_pattern_offset_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.CampaignsApi()
var patternOffsetRequest = ; // {PatternOffsetRequest} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.campaignsDomainGenerationPatternOffset(patternOffsetRequest, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class campaignsDomainGenerationPatternOffsetExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new CampaignsApi();
            var patternOffsetRequest = new PatternOffsetRequest(); // PatternOffsetRequest | 

            try {
                // Get current global pattern offset for domain generation config
                campaigns_domain_generation_pattern_offset_200_response result = apiInstance.campaignsDomainGenerationPatternOffset(patternOffsetRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling CampaignsApi.campaignsDomainGenerationPatternOffset: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CampaignsApi();
$patternOffsetRequest = ; // PatternOffsetRequest | 

try {
    $result = $api_instance->campaignsDomainGenerationPatternOffset($patternOffsetRequest);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling CampaignsApi->campaignsDomainGenerationPatternOffset: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::CampaignsApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CampaignsApi->new();
my $patternOffsetRequest = WWW::OPenAPIClient::Object::PatternOffsetRequest->new(); # PatternOffsetRequest | 

eval {
    my $result = $api_instance->campaignsDomainGenerationPatternOffset(patternOffsetRequest => $patternOffsetRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling CampaignsApi->campaignsDomainGenerationPatternOffset: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.CampaignsApi()
patternOffsetRequest =  # PatternOffsetRequest | 

try:
    # Get current global pattern offset for domain generation config
    api_response = api_instance.campaigns_domain_generation_pattern_offset(patternOffsetRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CampaignsApi->campaignsDomainGenerationPatternOffset: %s\n" % e)

extern crate CampaignsApi;

pub fn main() {
    let patternOffsetRequest = ; // PatternOffsetRequest

    let mut context = CampaignsApi::Context::default();
    let result = client.campaignsDomainGenerationPatternOffset(patternOffsetRequest, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.CampaignsApi;

import java.io.File;
import java.util.*;

public class CampaignsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        CampaignsApi apiInstance = new CampaignsApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        Integer limit = 56; // Integer | 
        Integer offset = 56; // Integer | 

        try {
            campaigns_domains_list_200_response result = apiInstance.campaignsDomainsList(campaignId, limit, offset);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#campaignsDomainsList");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UUID campaignId = new UUID(); // UUID | 
final Integer limit = new Integer(); // Integer | 
final Integer offset = new Integer(); // Integer | 

try {
    final result = await api_instance.campaignsDomainsList(campaignId, limit, offset);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->campaignsDomainsList: $e\n');
}

import org.openapitools.client.api.CampaignsApi;

public class CampaignsApiExample {
    public static void main(String[] args) {
        CampaignsApi apiInstance = new CampaignsApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        Integer limit = 56; // Integer | 
        Integer offset = 56; // Integer | 

        try {
            campaigns_domains_list_200_response result = apiInstance.campaignsDomainsList(campaignId, limit, offset);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#campaignsDomainsList");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
CampaignsApi *apiInstance = [[CampaignsApi alloc] init];
UUID *campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (default to null)
Integer *limit = 56; //  (optional) (default to 100)
Integer *offset = 56; //  (optional) (default to 0)

// List generated domains for a campaign
[apiInstance campaignsDomainsListWith:campaignId
    limit:limit
    offset:offset
              completionHandler: ^(campaigns_domains_list_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.CampaignsApi()
var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} 
var opts = {
  'limit': 56, // {Integer} 
  'offset': 56 // {Integer} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.campaignsDomainsList(campaignId, opts, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class campaignsDomainsListExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new CampaignsApi();
            var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (default to null)
            var limit = 56;  // Integer |  (optional)  (default to 100)
            var offset = 56;  // Integer |  (optional)  (default to 0)

            try {
                // List generated domains for a campaign
                campaigns_domains_list_200_response result = apiInstance.campaignsDomainsList(campaignId, limit, offset);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling CampaignsApi.campaignsDomainsList: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CampaignsApi();
$campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
$limit = 56; // Integer | 
$offset = 56; // Integer | 

try {
    $result = $api_instance->campaignsDomainsList($campaignId, $limit, $offset);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling CampaignsApi->campaignsDomainsList: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::CampaignsApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CampaignsApi->new();
my $campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 
my $limit = 56; # Integer | 
my $offset = 56; # Integer | 

eval {
    my $result = $api_instance->campaignsDomainsList(campaignId => $campaignId, limit => $limit, offset => $offset);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling CampaignsApi->campaignsDomainsList: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.CampaignsApi()
campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (default to null)
limit = 56 # Integer |  (optional) (default to 100)
offset = 56 # Integer |  (optional) (default to 0)

try:
    # List generated domains for a campaign
    api_response = api_instance.campaigns_domains_list(campaignId, limit=limit, offset=offset)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CampaignsApi->campaignsDomainsList: %s\n" % e)

extern crate CampaignsApi;

pub fn main() {
    let campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID
    let limit = 56; // Integer
    let offset = 56; // Integer

    let mut context = CampaignsApi::Context::default();
    let result = client.campaignsDomainsList(campaignId, limit, offset, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.CampaignsApi;

import java.io.File;
import java.util.*;

public class CampaignsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        CampaignsApi apiInstance = new CampaignsApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            campaigns_enriched_get_200_response result = apiInstance.campaignsEnrichedGet(campaignId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#campaignsEnrichedGet");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UUID campaignId = new UUID(); // UUID | 

try {
    final result = await api_instance.campaignsEnrichedGet(campaignId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->campaignsEnrichedGet: $e\n');
}

import org.openapitools.client.api.CampaignsApi;

public class CampaignsApiExample {
    public static void main(String[] args) {
        CampaignsApi apiInstance = new CampaignsApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            campaigns_enriched_get_200_response result = apiInstance.campaignsEnrichedGet(campaignId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#campaignsEnrichedGet");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
CampaignsApi *apiInstance = [[CampaignsApi alloc] init];
UUID *campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (default to null)

// Get enriched campaign details
[apiInstance campaignsEnrichedGetWith:campaignId
              completionHandler: ^(campaigns_enriched_get_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.CampaignsApi()
var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.campaignsEnrichedGet(campaignId, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class campaignsEnrichedGetExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new CampaignsApi();
            var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (default to null)

            try {
                // Get enriched campaign details
                campaigns_enriched_get_200_response result = apiInstance.campaignsEnrichedGet(campaignId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling CampaignsApi.campaignsEnrichedGet: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CampaignsApi();
$campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

try {
    $result = $api_instance->campaignsEnrichedGet($campaignId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling CampaignsApi->campaignsEnrichedGet: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::CampaignsApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CampaignsApi->new();
my $campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 

eval {
    my $result = $api_instance->campaignsEnrichedGet(campaignId => $campaignId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling CampaignsApi->campaignsEnrichedGet: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.CampaignsApi()
campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (default to null)

try:
    # Get enriched campaign details
    api_response = api_instance.campaigns_enriched_get(campaignId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CampaignsApi->campaignsEnrichedGet: %s\n" % e)

extern crate CampaignsApi;

pub fn main() {
    let campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID

    let mut context = CampaignsApi::Context::default();
    let result = client.campaignsEnrichedGet(campaignId, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.CampaignsApi;

import java.io.File;
import java.util.*;

public class CampaignsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        CampaignsApi apiInstance = new CampaignsApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            campaigns_create_201_response result = apiInstance.campaignsGet(campaignId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#campaignsGet");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UUID campaignId = new UUID(); // UUID | 

try {
    final result = await api_instance.campaignsGet(campaignId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->campaignsGet: $e\n');
}

import org.openapitools.client.api.CampaignsApi;

public class CampaignsApiExample {
    public static void main(String[] args) {
        CampaignsApi apiInstance = new CampaignsApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            campaigns_create_201_response result = apiInstance.campaignsGet(campaignId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#campaignsGet");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
CampaignsApi *apiInstance = [[CampaignsApi alloc] init];
UUID *campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (default to null)

// Get campaign
[apiInstance campaignsGetWith:campaignId
              completionHandler: ^(campaigns_create_201_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.CampaignsApi()
var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.campaignsGet(campaignId, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class campaignsGetExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new CampaignsApi();
            var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (default to null)

            try {
                // Get campaign
                campaigns_create_201_response result = apiInstance.campaignsGet(campaignId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling CampaignsApi.campaignsGet: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CampaignsApi();
$campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

try {
    $result = $api_instance->campaignsGet($campaignId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling CampaignsApi->campaignsGet: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::CampaignsApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CampaignsApi->new();
my $campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 

eval {
    my $result = $api_instance->campaignsGet(campaignId => $campaignId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling CampaignsApi->campaignsGet: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.CampaignsApi()
campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (default to null)

try:
    # Get campaign
    api_response = api_instance.campaigns_get(campaignId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CampaignsApi->campaignsGet: %s\n" % e)

extern crate CampaignsApi;

pub fn main() {
    let campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID

    let mut context = CampaignsApi::Context::default();
    let result = client.campaignsGet(campaignId, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.CampaignsApi;

import java.io.File;
import java.util.*;

public class CampaignsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        CampaignsApi apiInstance = new CampaignsApi();

        try {
            campaigns_list_200_response result = apiInstance.campaignsList();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#campaignsList");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


try {
    final result = await api_instance.campaignsList();
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->campaignsList: $e\n');
}

import org.openapitools.client.api.CampaignsApi;

public class CampaignsApiExample {
    public static void main(String[] args) {
        CampaignsApi apiInstance = new CampaignsApi();

        try {
            campaigns_list_200_response result = apiInstance.campaignsList();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#campaignsList");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
CampaignsApi *apiInstance = [[CampaignsApi alloc] init];

// List campaigns
[apiInstance campaignsListWithCompletionHandler: 
              ^(campaigns_list_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.CampaignsApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.campaignsList(callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class campaignsListExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new CampaignsApi();

            try {
                // List campaigns
                campaigns_list_200_response result = apiInstance.campaignsList();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling CampaignsApi.campaignsList: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CampaignsApi();

try {
    $result = $api_instance->campaignsList();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling CampaignsApi->campaignsList: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::CampaignsApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CampaignsApi->new();

eval {
    my $result = $api_instance->campaignsList();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling CampaignsApi->campaignsList: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.CampaignsApi()

try:
    # List campaigns
    api_response = api_instance.campaigns_list()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CampaignsApi->campaignsList: %s\n" % e)

extern crate CampaignsApi;

pub fn main() {

    let mut context = CampaignsApi::Context::default();
    let result = client.campaignsList(&context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.CampaignsApi;

import java.io.File;
import java.util.*;

public class CampaignsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        CampaignsApi apiInstance = new CampaignsApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        CampaignsModeUpdateRequest campaignsModeUpdateRequest = ; // CampaignsModeUpdateRequest | 

        try {
            campaigns_mode_update_200_response result = apiInstance.campaignsModeUpdate(campaignId, campaignsModeUpdateRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#campaignsModeUpdate");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UUID campaignId = new UUID(); // UUID | 
final CampaignsModeUpdateRequest campaignsModeUpdateRequest = new CampaignsModeUpdateRequest(); // CampaignsModeUpdateRequest | 

try {
    final result = await api_instance.campaignsModeUpdate(campaignId, campaignsModeUpdateRequest);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->campaignsModeUpdate: $e\n');
}

import org.openapitools.client.api.CampaignsApi;

public class CampaignsApiExample {
    public static void main(String[] args) {
        CampaignsApi apiInstance = new CampaignsApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        CampaignsModeUpdateRequest campaignsModeUpdateRequest = ; // CampaignsModeUpdateRequest | 

        try {
            campaigns_mode_update_200_response result = apiInstance.campaignsModeUpdate(campaignId, campaignsModeUpdateRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#campaignsModeUpdate");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
CampaignsApi *apiInstance = [[CampaignsApi alloc] init];
UUID *campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (default to null)
CampaignsModeUpdateRequest *campaignsModeUpdateRequest = ; // 

// Update campaign execution mode
[apiInstance campaignsModeUpdateWith:campaignId
    campaignsModeUpdateRequest:campaignsModeUpdateRequest
              completionHandler: ^(campaigns_mode_update_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.CampaignsApi()
var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} 
var campaignsModeUpdateRequest = ; // {CampaignsModeUpdateRequest} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.campaignsModeUpdate(campaignId, campaignsModeUpdateRequest, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class campaignsModeUpdateExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new CampaignsApi();
            var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (default to null)
            var campaignsModeUpdateRequest = new CampaignsModeUpdateRequest(); // CampaignsModeUpdateRequest | 

            try {
                // Update campaign execution mode
                campaigns_mode_update_200_response result = apiInstance.campaignsModeUpdate(campaignId, campaignsModeUpdateRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling CampaignsApi.campaignsModeUpdate: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CampaignsApi();
$campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
$campaignsModeUpdateRequest = ; // CampaignsModeUpdateRequest | 

try {
    $result = $api_instance->campaignsModeUpdate($campaignId, $campaignsModeUpdateRequest);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling CampaignsApi->campaignsModeUpdate: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::CampaignsApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CampaignsApi->new();
my $campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 
my $campaignsModeUpdateRequest = WWW::OPenAPIClient::Object::CampaignsModeUpdateRequest->new(); # CampaignsModeUpdateRequest | 

eval {
    my $result = $api_instance->campaignsModeUpdate(campaignId => $campaignId, campaignsModeUpdateRequest => $campaignsModeUpdateRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling CampaignsApi->campaignsModeUpdate: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.CampaignsApi()
campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (default to null)
campaignsModeUpdateRequest =  # CampaignsModeUpdateRequest | 

try:
    # Update campaign execution mode
    api_response = api_instance.campaigns_mode_update(campaignId, campaignsModeUpdateRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CampaignsApi->campaignsModeUpdate: %s\n" % e)

extern crate CampaignsApi;

pub fn main() {
    let campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID
    let campaignsModeUpdateRequest = ; // CampaignsModeUpdateRequest

    let mut context = CampaignsApi::Context::default();
    let result = client.campaignsModeUpdate(campaignId, campaignsModeUpdateRequest, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.CampaignsApi;

import java.io.File;
import java.util.*;

public class CampaignsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        CampaignsApi apiInstance = new CampaignsApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            campaigns_phase_configs_list_200_response result = apiInstance.campaignsPhaseConfigsList(campaignId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#campaignsPhaseConfigsList");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UUID campaignId = new UUID(); // UUID | 

try {
    final result = await api_instance.campaignsPhaseConfigsList(campaignId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->campaignsPhaseConfigsList: $e\n');
}

import org.openapitools.client.api.CampaignsApi;

public class CampaignsApiExample {
    public static void main(String[] args) {
        CampaignsApi apiInstance = new CampaignsApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            campaigns_phase_configs_list_200_response result = apiInstance.campaignsPhaseConfigsList(campaignId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#campaignsPhaseConfigsList");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
CampaignsApi *apiInstance = [[CampaignsApi alloc] init];
UUID *campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (default to null)

// List stored phase configurations for a campaign
[apiInstance campaignsPhaseConfigsListWith:campaignId
              completionHandler: ^(campaigns_phase_configs_list_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.CampaignsApi()
var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.campaignsPhaseConfigsList(campaignId, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class campaignsPhaseConfigsListExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new CampaignsApi();
            var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (default to null)

            try {
                // List stored phase configurations for a campaign
                campaigns_phase_configs_list_200_response result = apiInstance.campaignsPhaseConfigsList(campaignId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling CampaignsApi.campaignsPhaseConfigsList: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CampaignsApi();
$campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

try {
    $result = $api_instance->campaignsPhaseConfigsList($campaignId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling CampaignsApi->campaignsPhaseConfigsList: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::CampaignsApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CampaignsApi->new();
my $campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 

eval {
    my $result = $api_instance->campaignsPhaseConfigsList(campaignId => $campaignId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling CampaignsApi->campaignsPhaseConfigsList: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.CampaignsApi()
campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (default to null)

try:
    # List stored phase configurations for a campaign
    api_response = api_instance.campaigns_phase_configs_list(campaignId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CampaignsApi->campaignsPhaseConfigsList: %s\n" % e)

extern crate CampaignsApi;

pub fn main() {
    let campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID

    let mut context = CampaignsApi::Context::default();
    let result = client.campaignsPhaseConfigsList(campaignId, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.CampaignsApi;

import java.io.File;
import java.util.*;

public class CampaignsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        CampaignsApi apiInstance = new CampaignsApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        String phase = phase_example; // String | 
        PhaseConfigurationRequest phaseConfigurationRequest = ; // PhaseConfigurationRequest | 

        try {
            campaigns_phase_status_200_response result = apiInstance.campaignsPhaseConfigure(campaignId, phase, phaseConfigurationRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#campaignsPhaseConfigure");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UUID campaignId = new UUID(); // UUID | 
final String phase = new String(); // String | 
final PhaseConfigurationRequest phaseConfigurationRequest = new PhaseConfigurationRequest(); // PhaseConfigurationRequest | 

try {
    final result = await api_instance.campaignsPhaseConfigure(campaignId, phase, phaseConfigurationRequest);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->campaignsPhaseConfigure: $e\n');
}

import org.openapitools.client.api.CampaignsApi;

public class CampaignsApiExample {
    public static void main(String[] args) {
        CampaignsApi apiInstance = new CampaignsApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        String phase = phase_example; // String | 
        PhaseConfigurationRequest phaseConfigurationRequest = ; // PhaseConfigurationRequest | 

        try {
            campaigns_phase_status_200_response result = apiInstance.campaignsPhaseConfigure(campaignId, phase, phaseConfigurationRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#campaignsPhaseConfigure");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
CampaignsApi *apiInstance = [[CampaignsApi alloc] init];
UUID *campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (default to null)
String *phase = phase_example; //  (default to null)
PhaseConfigurationRequest *phaseConfigurationRequest = ; // 

// Configure campaign phase
[apiInstance campaignsPhaseConfigureWith:campaignId
    phase:phase
    phaseConfigurationRequest:phaseConfigurationRequest
              completionHandler: ^(campaigns_phase_status_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.CampaignsApi()
var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} 
var phase = phase_example; // {String} 
var phaseConfigurationRequest = ; // {PhaseConfigurationRequest} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.campaignsPhaseConfigure(campaignId, phase, phaseConfigurationRequest, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class campaignsPhaseConfigureExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new CampaignsApi();
            var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (default to null)
            var phase = phase_example;  // String |  (default to null)
            var phaseConfigurationRequest = new PhaseConfigurationRequest(); // PhaseConfigurationRequest | 

            try {
                // Configure campaign phase
                campaigns_phase_status_200_response result = apiInstance.campaignsPhaseConfigure(campaignId, phase, phaseConfigurationRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling CampaignsApi.campaignsPhaseConfigure: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CampaignsApi();
$campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
$phase = phase_example; // String | 
$phaseConfigurationRequest = ; // PhaseConfigurationRequest | 

try {
    $result = $api_instance->campaignsPhaseConfigure($campaignId, $phase, $phaseConfigurationRequest);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling CampaignsApi->campaignsPhaseConfigure: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::CampaignsApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CampaignsApi->new();
my $campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 
my $phase = phase_example; # String | 
my $phaseConfigurationRequest = WWW::OPenAPIClient::Object::PhaseConfigurationRequest->new(); # PhaseConfigurationRequest | 

eval {
    my $result = $api_instance->campaignsPhaseConfigure(campaignId => $campaignId, phase => $phase, phaseConfigurationRequest => $phaseConfigurationRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling CampaignsApi->campaignsPhaseConfigure: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.CampaignsApi()
campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (default to null)
phase = phase_example # String |  (default to null)
phaseConfigurationRequest =  # PhaseConfigurationRequest | 

try:
    # Configure campaign phase
    api_response = api_instance.campaigns_phase_configure(campaignId, phase, phaseConfigurationRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CampaignsApi->campaignsPhaseConfigure: %s\n" % e)

extern crate CampaignsApi;

pub fn main() {
    let campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID
    let phase = phase_example; // String
    let phaseConfigurationRequest = ; // PhaseConfigurationRequest

    let mut context = CampaignsApi::Context::default();
    let result = client.campaignsPhaseConfigure(campaignId, phase, phaseConfigurationRequest, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.CampaignsApi;

import java.io.File;
import java.util.*;

public class CampaignsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        CampaignsApi apiInstance = new CampaignsApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        String phaseType = phaseType_example; // String | 

        try {
            apiInstance.campaignsPhaseExecutionDelete(campaignId, phaseType);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#campaignsPhaseExecutionDelete");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UUID campaignId = new UUID(); // UUID | 
final String phaseType = new String(); // String | 

try {
    final result = await api_instance.campaignsPhaseExecutionDelete(campaignId, phaseType);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->campaignsPhaseExecutionDelete: $e\n');
}

import org.openapitools.client.api.CampaignsApi;

public class CampaignsApiExample {
    public static void main(String[] args) {
        CampaignsApi apiInstance = new CampaignsApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        String phaseType = phaseType_example; // String | 

        try {
            apiInstance.campaignsPhaseExecutionDelete(campaignId, phaseType);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#campaignsPhaseExecutionDelete");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
CampaignsApi *apiInstance = [[CampaignsApi alloc] init];
UUID *campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (default to null)
String *phaseType = phaseType_example; //  (default to null)

// Delete phase execution by phase type
[apiInstance campaignsPhaseExecutionDeleteWith:campaignId
    phaseType:phaseType
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.CampaignsApi()
var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} 
var phaseType = phaseType_example; // {String} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.campaignsPhaseExecutionDelete(campaignId, phaseType, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class campaignsPhaseExecutionDeleteExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new CampaignsApi();
            var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (default to null)
            var phaseType = phaseType_example;  // String |  (default to null)

            try {
                // Delete phase execution by phase type
                apiInstance.campaignsPhaseExecutionDelete(campaignId, phaseType);
            } catch (Exception e) {
                Debug.Print("Exception when calling CampaignsApi.campaignsPhaseExecutionDelete: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CampaignsApi();
$campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
$phaseType = phaseType_example; // String | 

try {
    $api_instance->campaignsPhaseExecutionDelete($campaignId, $phaseType);
} catch (Exception $e) {
    echo 'Exception when calling CampaignsApi->campaignsPhaseExecutionDelete: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::CampaignsApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CampaignsApi->new();
my $campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 
my $phaseType = phaseType_example; # String | 

eval {
    $api_instance->campaignsPhaseExecutionDelete(campaignId => $campaignId, phaseType => $phaseType);
};
if ($@) {
    warn "Exception when calling CampaignsApi->campaignsPhaseExecutionDelete: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.CampaignsApi()
campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (default to null)
phaseType = phaseType_example # String |  (default to null)

try:
    # Delete phase execution by phase type
    api_instance.campaigns_phase_execution_delete(campaignId, phaseType)
except ApiException as e:
    print("Exception when calling CampaignsApi->campaignsPhaseExecutionDelete: %s\n" % e)

extern crate CampaignsApi;

pub fn main() {
    let campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID
    let phaseType = phaseType_example; // String

    let mut context = CampaignsApi::Context::default();
    let result = client.campaignsPhaseExecutionDelete(campaignId, phaseType, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.CampaignsApi;

import java.io.File;
import java.util.*;

public class CampaignsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        CampaignsApi apiInstance = new CampaignsApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        String phaseType = phaseType_example; // String | 

        try {
            campaigns_phase_execution_get_200_response result = apiInstance.campaignsPhaseExecutionGet(campaignId, phaseType);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#campaignsPhaseExecutionGet");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UUID campaignId = new UUID(); // UUID | 
final String phaseType = new String(); // String | 

try {
    final result = await api_instance.campaignsPhaseExecutionGet(campaignId, phaseType);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->campaignsPhaseExecutionGet: $e\n');
}

import org.openapitools.client.api.CampaignsApi;

public class CampaignsApiExample {
    public static void main(String[] args) {
        CampaignsApi apiInstance = new CampaignsApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        String phaseType = phaseType_example; // String | 

        try {
            campaigns_phase_execution_get_200_response result = apiInstance.campaignsPhaseExecutionGet(campaignId, phaseType);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#campaignsPhaseExecutionGet");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
CampaignsApi *apiInstance = [[CampaignsApi alloc] init];
UUID *campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (default to null)
String *phaseType = phaseType_example; //  (default to null)

// Get phase execution by phase type
[apiInstance campaignsPhaseExecutionGetWith:campaignId
    phaseType:phaseType
              completionHandler: ^(campaigns_phase_execution_get_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.CampaignsApi()
var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} 
var phaseType = phaseType_example; // {String} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.campaignsPhaseExecutionGet(campaignId, phaseType, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class campaignsPhaseExecutionGetExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new CampaignsApi();
            var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (default to null)
            var phaseType = phaseType_example;  // String |  (default to null)

            try {
                // Get phase execution by phase type
                campaigns_phase_execution_get_200_response result = apiInstance.campaignsPhaseExecutionGet(campaignId, phaseType);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling CampaignsApi.campaignsPhaseExecutionGet: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CampaignsApi();
$campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
$phaseType = phaseType_example; // String | 

try {
    $result = $api_instance->campaignsPhaseExecutionGet($campaignId, $phaseType);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling CampaignsApi->campaignsPhaseExecutionGet: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::CampaignsApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CampaignsApi->new();
my $campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 
my $phaseType = phaseType_example; # String | 

eval {
    my $result = $api_instance->campaignsPhaseExecutionGet(campaignId => $campaignId, phaseType => $phaseType);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling CampaignsApi->campaignsPhaseExecutionGet: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.CampaignsApi()
campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (default to null)
phaseType = phaseType_example # String |  (default to null)

try:
    # Get phase execution by phase type
    api_response = api_instance.campaigns_phase_execution_get(campaignId, phaseType)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CampaignsApi->campaignsPhaseExecutionGet: %s\n" % e)

extern crate CampaignsApi;

pub fn main() {
    let campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID
    let phaseType = phaseType_example; // String

    let mut context = CampaignsApi::Context::default();
    let result = client.campaignsPhaseExecutionGet(campaignId, phaseType, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.CampaignsApi;

import java.io.File;
import java.util.*;

public class CampaignsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        CampaignsApi apiInstance = new CampaignsApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        String phaseType = phaseType_example; // String | 
        PhaseExecutionUpdate phaseExecutionUpdate = ; // PhaseExecutionUpdate | 

        try {
            campaigns_phase_execution_get_200_response result = apiInstance.campaignsPhaseExecutionPut(campaignId, phaseType, phaseExecutionUpdate);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#campaignsPhaseExecutionPut");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UUID campaignId = new UUID(); // UUID | 
final String phaseType = new String(); // String | 
final PhaseExecutionUpdate phaseExecutionUpdate = new PhaseExecutionUpdate(); // PhaseExecutionUpdate | 

try {
    final result = await api_instance.campaignsPhaseExecutionPut(campaignId, phaseType, phaseExecutionUpdate);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->campaignsPhaseExecutionPut: $e\n');
}

import org.openapitools.client.api.CampaignsApi;

public class CampaignsApiExample {
    public static void main(String[] args) {
        CampaignsApi apiInstance = new CampaignsApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        String phaseType = phaseType_example; // String | 
        PhaseExecutionUpdate phaseExecutionUpdate = ; // PhaseExecutionUpdate | 

        try {
            campaigns_phase_execution_get_200_response result = apiInstance.campaignsPhaseExecutionPut(campaignId, phaseType, phaseExecutionUpdate);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#campaignsPhaseExecutionPut");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
CampaignsApi *apiInstance = [[CampaignsApi alloc] init];
UUID *campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (default to null)
String *phaseType = phaseType_example; //  (default to null)
PhaseExecutionUpdate *phaseExecutionUpdate = ; // 

// Update phase execution by phase type
[apiInstance campaignsPhaseExecutionPutWith:campaignId
    phaseType:phaseType
    phaseExecutionUpdate:phaseExecutionUpdate
              completionHandler: ^(campaigns_phase_execution_get_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.CampaignsApi()
var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} 
var phaseType = phaseType_example; // {String} 
var phaseExecutionUpdate = ; // {PhaseExecutionUpdate} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.campaignsPhaseExecutionPut(campaignId, phaseType, phaseExecutionUpdate, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class campaignsPhaseExecutionPutExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new CampaignsApi();
            var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (default to null)
            var phaseType = phaseType_example;  // String |  (default to null)
            var phaseExecutionUpdate = new PhaseExecutionUpdate(); // PhaseExecutionUpdate | 

            try {
                // Update phase execution by phase type
                campaigns_phase_execution_get_200_response result = apiInstance.campaignsPhaseExecutionPut(campaignId, phaseType, phaseExecutionUpdate);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling CampaignsApi.campaignsPhaseExecutionPut: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CampaignsApi();
$campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
$phaseType = phaseType_example; // String | 
$phaseExecutionUpdate = ; // PhaseExecutionUpdate | 

try {
    $result = $api_instance->campaignsPhaseExecutionPut($campaignId, $phaseType, $phaseExecutionUpdate);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling CampaignsApi->campaignsPhaseExecutionPut: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::CampaignsApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CampaignsApi->new();
my $campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 
my $phaseType = phaseType_example; # String | 
my $phaseExecutionUpdate = WWW::OPenAPIClient::Object::PhaseExecutionUpdate->new(); # PhaseExecutionUpdate | 

eval {
    my $result = $api_instance->campaignsPhaseExecutionPut(campaignId => $campaignId, phaseType => $phaseType, phaseExecutionUpdate => $phaseExecutionUpdate);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling CampaignsApi->campaignsPhaseExecutionPut: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.CampaignsApi()
campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (default to null)
phaseType = phaseType_example # String |  (default to null)
phaseExecutionUpdate =  # PhaseExecutionUpdate | 

try:
    # Update phase execution by phase type
    api_response = api_instance.campaigns_phase_execution_put(campaignId, phaseType, phaseExecutionUpdate)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CampaignsApi->campaignsPhaseExecutionPut: %s\n" % e)

extern crate CampaignsApi;

pub fn main() {
    let campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID
    let phaseType = phaseType_example; // String
    let phaseExecutionUpdate = ; // PhaseExecutionUpdate

    let mut context = CampaignsApi::Context::default();
    let result = client.campaignsPhaseExecutionPut(campaignId, phaseType, phaseExecutionUpdate, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.CampaignsApi;

import java.io.File;
import java.util.*;

public class CampaignsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        CampaignsApi apiInstance = new CampaignsApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            campaigns_phase_executions_list_200_response result = apiInstance.campaignsPhaseExecutionsList(campaignId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#campaignsPhaseExecutionsList");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UUID campaignId = new UUID(); // UUID | 

try {
    final result = await api_instance.campaignsPhaseExecutionsList(campaignId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->campaignsPhaseExecutionsList: $e\n');
}

import org.openapitools.client.api.CampaignsApi;

public class CampaignsApiExample {
    public static void main(String[] args) {
        CampaignsApi apiInstance = new CampaignsApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            campaigns_phase_executions_list_200_response result = apiInstance.campaignsPhaseExecutionsList(campaignId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#campaignsPhaseExecutionsList");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
CampaignsApi *apiInstance = [[CampaignsApi alloc] init];
UUID *campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (default to null)

// Get campaign state and phase executions
[apiInstance campaignsPhaseExecutionsListWith:campaignId
              completionHandler: ^(campaigns_phase_executions_list_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.CampaignsApi()
var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.campaignsPhaseExecutionsList(campaignId, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class campaignsPhaseExecutionsListExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new CampaignsApi();
            var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (default to null)

            try {
                // Get campaign state and phase executions
                campaigns_phase_executions_list_200_response result = apiInstance.campaignsPhaseExecutionsList(campaignId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling CampaignsApi.campaignsPhaseExecutionsList: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CampaignsApi();
$campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

try {
    $result = $api_instance->campaignsPhaseExecutionsList($campaignId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling CampaignsApi->campaignsPhaseExecutionsList: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::CampaignsApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CampaignsApi->new();
my $campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 

eval {
    my $result = $api_instance->campaignsPhaseExecutionsList(campaignId => $campaignId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling CampaignsApi->campaignsPhaseExecutionsList: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.CampaignsApi()
campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (default to null)

try:
    # Get campaign state and phase executions
    api_response = api_instance.campaigns_phase_executions_list(campaignId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CampaignsApi->campaignsPhaseExecutionsList: %s\n" % e)

extern crate CampaignsApi;

pub fn main() {
    let campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID

    let mut context = CampaignsApi::Context::default();
    let result = client.campaignsPhaseExecutionsList(campaignId, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.CampaignsApi;

import java.io.File;
import java.util.*;

public class CampaignsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        CampaignsApi apiInstance = new CampaignsApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        String phase = phase_example; // String | 

        try {
            campaigns_phase_status_200_response result = apiInstance.campaignsPhaseStart(campaignId, phase);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#campaignsPhaseStart");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UUID campaignId = new UUID(); // UUID | 
final String phase = new String(); // String | 

try {
    final result = await api_instance.campaignsPhaseStart(campaignId, phase);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->campaignsPhaseStart: $e\n');
}

import org.openapitools.client.api.CampaignsApi;

public class CampaignsApiExample {
    public static void main(String[] args) {
        CampaignsApi apiInstance = new CampaignsApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        String phase = phase_example; // String | 

        try {
            campaigns_phase_status_200_response result = apiInstance.campaignsPhaseStart(campaignId, phase);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#campaignsPhaseStart");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
CampaignsApi *apiInstance = [[CampaignsApi alloc] init];
UUID *campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (default to null)
String *phase = phase_example; //  (default to null)

// Start campaign phase
[apiInstance campaignsPhaseStartWith:campaignId
    phase:phase
              completionHandler: ^(campaigns_phase_status_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.CampaignsApi()
var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} 
var phase = phase_example; // {String} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.campaignsPhaseStart(campaignId, phase, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class campaignsPhaseStartExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new CampaignsApi();
            var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (default to null)
            var phase = phase_example;  // String |  (default to null)

            try {
                // Start campaign phase
                campaigns_phase_status_200_response result = apiInstance.campaignsPhaseStart(campaignId, phase);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling CampaignsApi.campaignsPhaseStart: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CampaignsApi();
$campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
$phase = phase_example; // String | 

try {
    $result = $api_instance->campaignsPhaseStart($campaignId, $phase);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling CampaignsApi->campaignsPhaseStart: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::CampaignsApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CampaignsApi->new();
my $campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 
my $phase = phase_example; # String | 

eval {
    my $result = $api_instance->campaignsPhaseStart(campaignId => $campaignId, phase => $phase);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling CampaignsApi->campaignsPhaseStart: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.CampaignsApi()
campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (default to null)
phase = phase_example # String |  (default to null)

try:
    # Start campaign phase
    api_response = api_instance.campaigns_phase_start(campaignId, phase)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CampaignsApi->campaignsPhaseStart: %s\n" % e)

extern crate CampaignsApi;

pub fn main() {
    let campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID
    let phase = phase_example; // String

    let mut context = CampaignsApi::Context::default();
    let result = client.campaignsPhaseStart(campaignId, phase, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.CampaignsApi;

import java.io.File;
import java.util.*;

public class CampaignsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        CampaignsApi apiInstance = new CampaignsApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        String phase = phase_example; // String | 

        try {
            campaigns_phase_status_200_response result = apiInstance.campaignsPhaseStatus(campaignId, phase);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#campaignsPhaseStatus");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UUID campaignId = new UUID(); // UUID | 
final String phase = new String(); // String | 

try {
    final result = await api_instance.campaignsPhaseStatus(campaignId, phase);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->campaignsPhaseStatus: $e\n');
}

import org.openapitools.client.api.CampaignsApi;

public class CampaignsApiExample {
    public static void main(String[] args) {
        CampaignsApi apiInstance = new CampaignsApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        String phase = phase_example; // String | 

        try {
            campaigns_phase_status_200_response result = apiInstance.campaignsPhaseStatus(campaignId, phase);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#campaignsPhaseStatus");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
CampaignsApi *apiInstance = [[CampaignsApi alloc] init];
UUID *campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (default to null)
String *phase = phase_example; //  (default to null)

// Get phase status
[apiInstance campaignsPhaseStatusWith:campaignId
    phase:phase
              completionHandler: ^(campaigns_phase_status_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.CampaignsApi()
var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} 
var phase = phase_example; // {String} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.campaignsPhaseStatus(campaignId, phase, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class campaignsPhaseStatusExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new CampaignsApi();
            var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (default to null)
            var phase = phase_example;  // String |  (default to null)

            try {
                // Get phase status
                campaigns_phase_status_200_response result = apiInstance.campaignsPhaseStatus(campaignId, phase);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling CampaignsApi.campaignsPhaseStatus: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CampaignsApi();
$campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
$phase = phase_example; // String | 

try {
    $result = $api_instance->campaignsPhaseStatus($campaignId, $phase);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling CampaignsApi->campaignsPhaseStatus: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::CampaignsApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CampaignsApi->new();
my $campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 
my $phase = phase_example; # String | 

eval {
    my $result = $api_instance->campaignsPhaseStatus(campaignId => $campaignId, phase => $phase);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling CampaignsApi->campaignsPhaseStatus: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.CampaignsApi()
campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (default to null)
phase = phase_example # String |  (default to null)

try:
    # Get phase status
    api_response = api_instance.campaigns_phase_status(campaignId, phase)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CampaignsApi->campaignsPhaseStatus: %s\n" % e)

extern crate CampaignsApi;

pub fn main() {
    let campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID
    let phase = phase_example; // String

    let mut context = CampaignsApi::Context::default();
    let result = client.campaignsPhaseStatus(campaignId, phase, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.CampaignsApi;

import java.io.File;
import java.util.*;

public class CampaignsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        CampaignsApi apiInstance = new CampaignsApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        String phase = phase_example; // String | 

        try {
            campaigns_phase_status_200_response result = apiInstance.campaignsPhaseStop(campaignId, phase);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#campaignsPhaseStop");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UUID campaignId = new UUID(); // UUID | 
final String phase = new String(); // String | 

try {
    final result = await api_instance.campaignsPhaseStop(campaignId, phase);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->campaignsPhaseStop: $e\n');
}

import org.openapitools.client.api.CampaignsApi;

public class CampaignsApiExample {
    public static void main(String[] args) {
        CampaignsApi apiInstance = new CampaignsApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        String phase = phase_example; // String | 

        try {
            campaigns_phase_status_200_response result = apiInstance.campaignsPhaseStop(campaignId, phase);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#campaignsPhaseStop");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
CampaignsApi *apiInstance = [[CampaignsApi alloc] init];
UUID *campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (default to null)
String *phase = phase_example; //  (default to null)

// Stop campaign phase
[apiInstance campaignsPhaseStopWith:campaignId
    phase:phase
              completionHandler: ^(campaigns_phase_status_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.CampaignsApi()
var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} 
var phase = phase_example; // {String} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.campaignsPhaseStop(campaignId, phase, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class campaignsPhaseStopExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new CampaignsApi();
            var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (default to null)
            var phase = phase_example;  // String |  (default to null)

            try {
                // Stop campaign phase
                campaigns_phase_status_200_response result = apiInstance.campaignsPhaseStop(campaignId, phase);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling CampaignsApi.campaignsPhaseStop: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CampaignsApi();
$campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
$phase = phase_example; // String | 

try {
    $result = $api_instance->campaignsPhaseStop($campaignId, $phase);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling CampaignsApi->campaignsPhaseStop: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::CampaignsApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CampaignsApi->new();
my $campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 
my $phase = phase_example; # String | 

eval {
    my $result = $api_instance->campaignsPhaseStop(campaignId => $campaignId, phase => $phase);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling CampaignsApi->campaignsPhaseStop: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.CampaignsApi()
campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (default to null)
phase = phase_example # String |  (default to null)

try:
    # Stop campaign phase
    api_response = api_instance.campaigns_phase_stop(campaignId, phase)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CampaignsApi->campaignsPhaseStop: %s\n" % e)

extern crate CampaignsApi;

pub fn main() {
    let campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID
    let phase = phase_example; // String

    let mut context = CampaignsApi::Context::default();
    let result = client.campaignsPhaseStop(campaignId, phase, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.CampaignsApi;

import java.io.File;
import java.util.*;

public class CampaignsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        CampaignsApi apiInstance = new CampaignsApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            campaigns_progress_200_response result = apiInstance.campaignsProgress(campaignId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#campaignsProgress");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UUID campaignId = new UUID(); // UUID | 

try {
    final result = await api_instance.campaignsProgress(campaignId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->campaignsProgress: $e\n');
}

import org.openapitools.client.api.CampaignsApi;

public class CampaignsApiExample {
    public static void main(String[] args) {
        CampaignsApi apiInstance = new CampaignsApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            campaigns_progress_200_response result = apiInstance.campaignsProgress(campaignId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#campaignsProgress");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
CampaignsApi *apiInstance = [[CampaignsApi alloc] init];
UUID *campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (default to null)

// Get campaign progress
[apiInstance campaignsProgressWith:campaignId
              completionHandler: ^(campaigns_progress_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.CampaignsApi()
var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.campaignsProgress(campaignId, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class campaignsProgressExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new CampaignsApi();
            var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (default to null)

            try {
                // Get campaign progress
                campaigns_progress_200_response result = apiInstance.campaignsProgress(campaignId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling CampaignsApi.campaignsProgress: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CampaignsApi();
$campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

try {
    $result = $api_instance->campaignsProgress($campaignId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling CampaignsApi->campaignsProgress: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::CampaignsApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CampaignsApi->new();
my $campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 

eval {
    my $result = $api_instance->campaignsProgress(campaignId => $campaignId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling CampaignsApi->campaignsProgress: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.CampaignsApi()
campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (default to null)

try:
    # Get campaign progress
    api_response = api_instance.campaigns_progress(campaignId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CampaignsApi->campaignsProgress: %s\n" % e)

extern crate CampaignsApi;

pub fn main() {
    let campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID

    let mut context = CampaignsApi::Context::default();
    let result = client.campaignsProgress(campaignId, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.CampaignsApi;

import java.io.File;
import java.util.*;

public class CampaignsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        CampaignsApi apiInstance = new CampaignsApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            apiInstance.campaignsStateDelete(campaignId);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#campaignsStateDelete");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UUID campaignId = new UUID(); // UUID | 

try {
    final result = await api_instance.campaignsStateDelete(campaignId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->campaignsStateDelete: $e\n');
}

import org.openapitools.client.api.CampaignsApi;

public class CampaignsApiExample {
    public static void main(String[] args) {
        CampaignsApi apiInstance = new CampaignsApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            apiInstance.campaignsStateDelete(campaignId);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#campaignsStateDelete");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
CampaignsApi *apiInstance = [[CampaignsApi alloc] init];
UUID *campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (default to null)

// Delete campaign state
[apiInstance campaignsStateDeleteWith:campaignId
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.CampaignsApi()
var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.campaignsStateDelete(campaignId, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class campaignsStateDeleteExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new CampaignsApi();
            var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (default to null)

            try {
                // Delete campaign state
                apiInstance.campaignsStateDelete(campaignId);
            } catch (Exception e) {
                Debug.Print("Exception when calling CampaignsApi.campaignsStateDelete: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CampaignsApi();
$campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

try {
    $api_instance->campaignsStateDelete($campaignId);
} catch (Exception $e) {
    echo 'Exception when calling CampaignsApi->campaignsStateDelete: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::CampaignsApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CampaignsApi->new();
my $campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 

eval {
    $api_instance->campaignsStateDelete(campaignId => $campaignId);
};
if ($@) {
    warn "Exception when calling CampaignsApi->campaignsStateDelete: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.CampaignsApi()
campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (default to null)

try:
    # Delete campaign state
    api_instance.campaigns_state_delete(campaignId)
except ApiException as e:
    print("Exception when calling CampaignsApi->campaignsStateDelete: %s\n" % e)

extern crate CampaignsApi;

pub fn main() {
    let campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID

    let mut context = CampaignsApi::Context::default();
    let result = client.campaignsStateDelete(campaignId, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.CampaignsApi;

import java.io.File;
import java.util.*;

public class CampaignsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        CampaignsApi apiInstance = new CampaignsApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            campaigns_state_get_200_response result = apiInstance.campaignsStateGet(campaignId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#campaignsStateGet");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UUID campaignId = new UUID(); // UUID | 

try {
    final result = await api_instance.campaignsStateGet(campaignId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->campaignsStateGet: $e\n');
}

import org.openapitools.client.api.CampaignsApi;

public class CampaignsApiExample {
    public static void main(String[] args) {
        CampaignsApi apiInstance = new CampaignsApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            campaigns_state_get_200_response result = apiInstance.campaignsStateGet(campaignId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#campaignsStateGet");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
CampaignsApi *apiInstance = [[CampaignsApi alloc] init];
UUID *campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (default to null)

// Get campaign state
[apiInstance campaignsStateGetWith:campaignId
              completionHandler: ^(campaigns_state_get_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.CampaignsApi()
var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.campaignsStateGet(campaignId, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class campaignsStateGetExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new CampaignsApi();
            var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (default to null)

            try {
                // Get campaign state
                campaigns_state_get_200_response result = apiInstance.campaignsStateGet(campaignId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling CampaignsApi.campaignsStateGet: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CampaignsApi();
$campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

try {
    $result = $api_instance->campaignsStateGet($campaignId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling CampaignsApi->campaignsStateGet: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::CampaignsApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CampaignsApi->new();
my $campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 

eval {
    my $result = $api_instance->campaignsStateGet(campaignId => $campaignId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling CampaignsApi->campaignsStateGet: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.CampaignsApi()
campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (default to null)

try:
    # Get campaign state
    api_response = api_instance.campaigns_state_get(campaignId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CampaignsApi->campaignsStateGet: %s\n" % e)

extern crate CampaignsApi;

pub fn main() {
    let campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID

    let mut context = CampaignsApi::Context::default();
    let result = client.campaignsStateGet(campaignId, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.CampaignsApi;

import java.io.File;
import java.util.*;

public class CampaignsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        CampaignsApi apiInstance = new CampaignsApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        CampaignStateUpdate campaignStateUpdate = ; // CampaignStateUpdate | 

        try {
            campaigns_state_get_200_response result = apiInstance.campaignsStatePut(campaignId, campaignStateUpdate);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#campaignsStatePut");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UUID campaignId = new UUID(); // UUID | 
final CampaignStateUpdate campaignStateUpdate = new CampaignStateUpdate(); // CampaignStateUpdate | 

try {
    final result = await api_instance.campaignsStatePut(campaignId, campaignStateUpdate);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->campaignsStatePut: $e\n');
}

import org.openapitools.client.api.CampaignsApi;

public class CampaignsApiExample {
    public static void main(String[] args) {
        CampaignsApi apiInstance = new CampaignsApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        CampaignStateUpdate campaignStateUpdate = ; // CampaignStateUpdate | 

        try {
            campaigns_state_get_200_response result = apiInstance.campaignsStatePut(campaignId, campaignStateUpdate);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#campaignsStatePut");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
CampaignsApi *apiInstance = [[CampaignsApi alloc] init];
UUID *campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (default to null)
CampaignStateUpdate *campaignStateUpdate = ; // 

// Update campaign state
[apiInstance campaignsStatePutWith:campaignId
    campaignStateUpdate:campaignStateUpdate
              completionHandler: ^(campaigns_state_get_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.CampaignsApi()
var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} 
var campaignStateUpdate = ; // {CampaignStateUpdate} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.campaignsStatePut(campaignId, campaignStateUpdate, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class campaignsStatePutExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new CampaignsApi();
            var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (default to null)
            var campaignStateUpdate = new CampaignStateUpdate(); // CampaignStateUpdate | 

            try {
                // Update campaign state
                campaigns_state_get_200_response result = apiInstance.campaignsStatePut(campaignId, campaignStateUpdate);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling CampaignsApi.campaignsStatePut: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CampaignsApi();
$campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
$campaignStateUpdate = ; // CampaignStateUpdate | 

try {
    $result = $api_instance->campaignsStatePut($campaignId, $campaignStateUpdate);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling CampaignsApi->campaignsStatePut: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::CampaignsApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CampaignsApi->new();
my $campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 
my $campaignStateUpdate = WWW::OPenAPIClient::Object::CampaignStateUpdate->new(); # CampaignStateUpdate | 

eval {
    my $result = $api_instance->campaignsStatePut(campaignId => $campaignId, campaignStateUpdate => $campaignStateUpdate);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling CampaignsApi->campaignsStatePut: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.CampaignsApi()
campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (default to null)
campaignStateUpdate =  # CampaignStateUpdate | 

try:
    # Update campaign state
    api_response = api_instance.campaigns_state_put(campaignId, campaignStateUpdate)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CampaignsApi->campaignsStatePut: %s\n" % e)

extern crate CampaignsApi;

pub fn main() {
    let campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID
    let campaignStateUpdate = ; // CampaignStateUpdate

    let mut context = CampaignsApi::Context::default();
    let result = client.campaignsStatePut(campaignId, campaignStateUpdate, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.CampaignsApi;

import java.io.File;
import java.util.*;

public class CampaignsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        CampaignsApi apiInstance = new CampaignsApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        UpdateCampaignRequest updateCampaignRequest = ; // UpdateCampaignRequest | 

        try {
            campaigns_create_201_response result = apiInstance.campaignsUpdate(campaignId, updateCampaignRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#campaignsUpdate");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UUID campaignId = new UUID(); // UUID | 
final UpdateCampaignRequest updateCampaignRequest = new UpdateCampaignRequest(); // UpdateCampaignRequest | 

try {
    final result = await api_instance.campaignsUpdate(campaignId, updateCampaignRequest);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->campaignsUpdate: $e\n');
}

import org.openapitools.client.api.CampaignsApi;

public class CampaignsApiExample {
    public static void main(String[] args) {
        CampaignsApi apiInstance = new CampaignsApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        UpdateCampaignRequest updateCampaignRequest = ; // UpdateCampaignRequest | 

        try {
            campaigns_create_201_response result = apiInstance.campaignsUpdate(campaignId, updateCampaignRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#campaignsUpdate");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
CampaignsApi *apiInstance = [[CampaignsApi alloc] init];
UUID *campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (default to null)
UpdateCampaignRequest *updateCampaignRequest = ; // 

// Update campaign
[apiInstance campaignsUpdateWith:campaignId
    updateCampaignRequest:updateCampaignRequest
              completionHandler: ^(campaigns_create_201_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.CampaignsApi()
var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} 
var updateCampaignRequest = ; // {UpdateCampaignRequest} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.campaignsUpdate(campaignId, updateCampaignRequest, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class campaignsUpdateExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new CampaignsApi();
            var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (default to null)
            var updateCampaignRequest = new UpdateCampaignRequest(); // UpdateCampaignRequest | 

            try {
                // Update campaign
                campaigns_create_201_response result = apiInstance.campaignsUpdate(campaignId, updateCampaignRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling CampaignsApi.campaignsUpdate: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CampaignsApi();
$campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
$updateCampaignRequest = ; // UpdateCampaignRequest | 

try {
    $result = $api_instance->campaignsUpdate($campaignId, $updateCampaignRequest);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling CampaignsApi->campaignsUpdate: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::CampaignsApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CampaignsApi->new();
my $campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 
my $updateCampaignRequest = WWW::OPenAPIClient::Object::UpdateCampaignRequest->new(); # UpdateCampaignRequest | 

eval {
    my $result = $api_instance->campaignsUpdate(campaignId => $campaignId, updateCampaignRequest => $updateCampaignRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling CampaignsApi->campaignsUpdate: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.CampaignsApi()
campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (default to null)
updateCampaignRequest =  # UpdateCampaignRequest | 

try:
    # Update campaign
    api_response = api_instance.campaigns_update(campaignId, updateCampaignRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CampaignsApi->campaignsUpdate: %s\n" % e)

extern crate CampaignsApi;

pub fn main() {
    let campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID
    let updateCampaignRequest = ; // UpdateCampaignRequest

    let mut context = CampaignsApi::Context::default();
    let result = client.campaignsUpdate(campaignId, updateCampaignRequest, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.CampaignsApi;

import java.io.File;
import java.util.*;

public class CampaignsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        CampaignsApi apiInstance = new CampaignsApi();
        UUID operationId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | Bulk operation ID to cancel

        try {
            cancelBulkOperation_200_response result = apiInstance.cancelBulkOperation(operationId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#cancelBulkOperation");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UUID operationId = new UUID(); // UUID | Bulk operation ID to cancel

try {
    final result = await api_instance.cancelBulkOperation(operationId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->cancelBulkOperation: $e\n');
}

import org.openapitools.client.api.CampaignsApi;

public class CampaignsApiExample {
    public static void main(String[] args) {
        CampaignsApi apiInstance = new CampaignsApi();
        UUID operationId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | Bulk operation ID to cancel

        try {
            cancelBulkOperation_200_response result = apiInstance.cancelBulkOperation(operationId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#cancelBulkOperation");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
CampaignsApi *apiInstance = [[CampaignsApi alloc] init];
UUID *operationId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // Bulk operation ID to cancel (default to null)

// Cancel bulk operation
[apiInstance cancelBulkOperationWith:operationId
              completionHandler: ^(cancelBulkOperation_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.CampaignsApi()
var operationId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} Bulk operation ID to cancel

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.cancelBulkOperation(operationId, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class cancelBulkOperationExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new CampaignsApi();
            var operationId = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID | Bulk operation ID to cancel (default to null)

            try {
                // Cancel bulk operation
                cancelBulkOperation_200_response result = apiInstance.cancelBulkOperation(operationId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling CampaignsApi.cancelBulkOperation: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CampaignsApi();
$operationId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | Bulk operation ID to cancel

try {
    $result = $api_instance->cancelBulkOperation($operationId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling CampaignsApi->cancelBulkOperation: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::CampaignsApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CampaignsApi->new();
my $operationId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | Bulk operation ID to cancel

eval {
    my $result = $api_instance->cancelBulkOperation(operationId => $operationId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling CampaignsApi->cancelBulkOperation: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.CampaignsApi()
operationId = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID | Bulk operation ID to cancel (default to null)

try:
    # Cancel bulk operation
    api_response = api_instance.cancel_bulk_operation(operationId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CampaignsApi->cancelBulkOperation: %s\n" % e)

extern crate CampaignsApi;

pub fn main() {
    let operationId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID

    let mut context = CampaignsApi::Context::default();
    let result = client.cancelBulkOperation(operationId, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.CampaignsApi;

import java.io.File;
import java.util.*;

public class CampaignsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        CampaignsApi apiInstance = new CampaignsApi();
        UUID operationId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | Bulk operation ID

        try {
            getBulkOperationStatus_200_response result = apiInstance.getBulkOperationStatus(operationId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#getBulkOperationStatus");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UUID operationId = new UUID(); // UUID | Bulk operation ID

try {
    final result = await api_instance.getBulkOperationStatus(operationId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->getBulkOperationStatus: $e\n');
}

import org.openapitools.client.api.CampaignsApi;

public class CampaignsApiExample {
    public static void main(String[] args) {
        CampaignsApi apiInstance = new CampaignsApi();
        UUID operationId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | Bulk operation ID

        try {
            getBulkOperationStatus_200_response result = apiInstance.getBulkOperationStatus(operationId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#getBulkOperationStatus");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
CampaignsApi *apiInstance = [[CampaignsApi alloc] init];
UUID *operationId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // Bulk operation ID (default to null)

// Get bulk operation status
[apiInstance getBulkOperationStatusWith:operationId
              completionHandler: ^(getBulkOperationStatus_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.CampaignsApi()
var operationId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} Bulk operation ID

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getBulkOperationStatus(operationId, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class getBulkOperationStatusExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new CampaignsApi();
            var operationId = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID | Bulk operation ID (default to null)

            try {
                // Get bulk operation status
                getBulkOperationStatus_200_response result = apiInstance.getBulkOperationStatus(operationId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling CampaignsApi.getBulkOperationStatus: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CampaignsApi();
$operationId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | Bulk operation ID

try {
    $result = $api_instance->getBulkOperationStatus($operationId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling CampaignsApi->getBulkOperationStatus: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::CampaignsApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CampaignsApi->new();
my $operationId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | Bulk operation ID

eval {
    my $result = $api_instance->getBulkOperationStatus(operationId => $operationId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling CampaignsApi->getBulkOperationStatus: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.CampaignsApi()
operationId = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID | Bulk operation ID (default to null)

try:
    # Get bulk operation status
    api_response = api_instance.get_bulk_operation_status(operationId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CampaignsApi->getBulkOperationStatus: %s\n" % e)

extern crate CampaignsApi;

pub fn main() {
    let operationId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID

    let mut context = CampaignsApi::Context::default();
    let result = client.getBulkOperationStatus(operationId, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.CampaignsApi;

import java.io.File;
import java.util.*;

public class CampaignsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        CampaignsApi apiInstance = new CampaignsApi();
        UUID allocationId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | Resource allocation ID

        try {
            getBulkResourceStatus_200_response result = apiInstance.getBulkResourceStatus(allocationId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#getBulkResourceStatus");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UUID allocationId = new UUID(); // UUID | Resource allocation ID

try {
    final result = await api_instance.getBulkResourceStatus(allocationId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->getBulkResourceStatus: $e\n');
}

import org.openapitools.client.api.CampaignsApi;

public class CampaignsApiExample {
    public static void main(String[] args) {
        CampaignsApi apiInstance = new CampaignsApi();
        UUID allocationId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | Resource allocation ID

        try {
            getBulkResourceStatus_200_response result = apiInstance.getBulkResourceStatus(allocationId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#getBulkResourceStatus");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
CampaignsApi *apiInstance = [[CampaignsApi alloc] init];
UUID *allocationId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // Resource allocation ID (default to null)

// Get bulk resource allocation status
[apiInstance getBulkResourceStatusWith:allocationId
              completionHandler: ^(getBulkResourceStatus_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.CampaignsApi()
var allocationId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} Resource allocation ID

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getBulkResourceStatus(allocationId, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class getBulkResourceStatusExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new CampaignsApi();
            var allocationId = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID | Resource allocation ID (default to null)

            try {
                // Get bulk resource allocation status
                getBulkResourceStatus_200_response result = apiInstance.getBulkResourceStatus(allocationId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling CampaignsApi.getBulkResourceStatus: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CampaignsApi();
$allocationId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | Resource allocation ID

try {
    $result = $api_instance->getBulkResourceStatus($allocationId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling CampaignsApi->getBulkResourceStatus: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::CampaignsApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CampaignsApi->new();
my $allocationId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | Resource allocation ID

eval {
    my $result = $api_instance->getBulkResourceStatus(allocationId => $allocationId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling CampaignsApi->getBulkResourceStatus: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.CampaignsApi()
allocationId = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID | Resource allocation ID (default to null)

try:
    # Get bulk resource allocation status
    api_response = api_instance.get_bulk_resource_status(allocationId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CampaignsApi->getBulkResourceStatus: %s\n" % e)

extern crate CampaignsApi;

pub fn main() {
    let allocationId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID

    let mut context = CampaignsApi::Context::default();
    let result = client.getBulkResourceStatus(allocationId, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DatabaseApi;

import java.io.File;
import java.util.*;

public class DatabaseApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        DatabaseApi apiInstance = new DatabaseApi();
        BulkDatabaseQueryRequest bulkDatabaseQueryRequest = ; // BulkDatabaseQueryRequest | 
        String xRequestedWith = xRequestedWith_example; // String | CSRF/XHR sentinel header. Must be exactly "XMLHttpRequest" for browser-initiated unsafe requests.

        try {
            db_bulk_query_200_response result = apiInstance.dbBulkQuery(bulkDatabaseQueryRequest, xRequestedWith);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DatabaseApi#dbBulkQuery");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final BulkDatabaseQueryRequest bulkDatabaseQueryRequest = new BulkDatabaseQueryRequest(); // BulkDatabaseQueryRequest | 
final String xRequestedWith = new String(); // String | CSRF/XHR sentinel header. Must be exactly "XMLHttpRequest" for browser-initiated unsafe requests.

try {
    final result = await api_instance.dbBulkQuery(bulkDatabaseQueryRequest, xRequestedWith);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->dbBulkQuery: $e\n');
}

import org.openapitools.client.api.DatabaseApi;

public class DatabaseApiExample {
    public static void main(String[] args) {
        DatabaseApi apiInstance = new DatabaseApi();
        BulkDatabaseQueryRequest bulkDatabaseQueryRequest = ; // BulkDatabaseQueryRequest | 
        String xRequestedWith = xRequestedWith_example; // String | CSRF/XHR sentinel header. Must be exactly "XMLHttpRequest" for browser-initiated unsafe requests.

        try {
            db_bulk_query_200_response result = apiInstance.dbBulkQuery(bulkDatabaseQueryRequest, xRequestedWith);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DatabaseApi#dbBulkQuery");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
DatabaseApi *apiInstance = [[DatabaseApi alloc] init];
BulkDatabaseQueryRequest *bulkDatabaseQueryRequest = ; // 
String *xRequestedWith = xRequestedWith_example; // CSRF/XHR sentinel header. Must be exactly "XMLHttpRequest" for browser-initiated unsafe requests. (optional) (default to null)

// Execute bulk database queries
[apiInstance dbBulkQueryWith:bulkDatabaseQueryRequest
    xRequestedWith:xRequestedWith
              completionHandler: ^(db_bulk_query_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.DatabaseApi()
var bulkDatabaseQueryRequest = ; // {BulkDatabaseQueryRequest} 
var opts = {
  'xRequestedWith': xRequestedWith_example // {String} CSRF/XHR sentinel header. Must be exactly "XMLHttpRequest" for browser-initiated unsafe requests.
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.dbBulkQuery(bulkDatabaseQueryRequest, opts, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class dbBulkQueryExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new DatabaseApi();
            var bulkDatabaseQueryRequest = new BulkDatabaseQueryRequest(); // BulkDatabaseQueryRequest | 
            var xRequestedWith = xRequestedWith_example;  // String | CSRF/XHR sentinel header. Must be exactly "XMLHttpRequest" for browser-initiated unsafe requests. (optional)  (default to null)

            try {
                // Execute bulk database queries
                db_bulk_query_200_response result = apiInstance.dbBulkQuery(bulkDatabaseQueryRequest, xRequestedWith);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DatabaseApi.dbBulkQuery: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DatabaseApi();
$bulkDatabaseQueryRequest = ; // BulkDatabaseQueryRequest | 
$xRequestedWith = xRequestedWith_example; // String | CSRF/XHR sentinel header. Must be exactly "XMLHttpRequest" for browser-initiated unsafe requests.

try {
    $result = $api_instance->dbBulkQuery($bulkDatabaseQueryRequest, $xRequestedWith);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DatabaseApi->dbBulkQuery: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DatabaseApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DatabaseApi->new();
my $bulkDatabaseQueryRequest = WWW::OPenAPIClient::Object::BulkDatabaseQueryRequest->new(); # BulkDatabaseQueryRequest | 
my $xRequestedWith = xRequestedWith_example; # String | CSRF/XHR sentinel header. Must be exactly "XMLHttpRequest" for browser-initiated unsafe requests.

eval {
    my $result = $api_instance->dbBulkQuery(bulkDatabaseQueryRequest => $bulkDatabaseQueryRequest, xRequestedWith => $xRequestedWith);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DatabaseApi->dbBulkQuery: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.DatabaseApi()
bulkDatabaseQueryRequest =  # BulkDatabaseQueryRequest | 
xRequestedWith = xRequestedWith_example # String | CSRF/XHR sentinel header. Must be exactly "XMLHttpRequest" for browser-initiated unsafe requests. (optional) (default to null)

try:
    # Execute bulk database queries
    api_response = api_instance.db_bulk_query(bulkDatabaseQueryRequest, xRequestedWith=xRequestedWith)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DatabaseApi->dbBulkQuery: %s\n" % e)

extern crate DatabaseApi;

pub fn main() {
    let bulkDatabaseQueryRequest = ; // BulkDatabaseQueryRequest
    let xRequestedWith = xRequestedWith_example; // String

    let mut context = DatabaseApi::Context::default();
    let result = client.dbBulkQuery(bulkDatabaseQueryRequest, xRequestedWith, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DatabaseApi;

import java.io.File;
import java.util.*;

public class DatabaseApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        DatabaseApi apiInstance = new DatabaseApi();
        BulkDatabaseStatsRequest bulkDatabaseStatsRequest = ; // BulkDatabaseStatsRequest | 
        String xRequestedWith = xRequestedWith_example; // String | CSRF/XHR sentinel header. Must be exactly "XMLHttpRequest" for browser-initiated unsafe requests.

        try {
            db_bulk_stats_200_response result = apiInstance.dbBulkStats(bulkDatabaseStatsRequest, xRequestedWith);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DatabaseApi#dbBulkStats");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final BulkDatabaseStatsRequest bulkDatabaseStatsRequest = new BulkDatabaseStatsRequest(); // BulkDatabaseStatsRequest | 
final String xRequestedWith = new String(); // String | CSRF/XHR sentinel header. Must be exactly "XMLHttpRequest" for browser-initiated unsafe requests.

try {
    final result = await api_instance.dbBulkStats(bulkDatabaseStatsRequest, xRequestedWith);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->dbBulkStats: $e\n');
}

import org.openapitools.client.api.DatabaseApi;

public class DatabaseApiExample {
    public static void main(String[] args) {
        DatabaseApi apiInstance = new DatabaseApi();
        BulkDatabaseStatsRequest bulkDatabaseStatsRequest = ; // BulkDatabaseStatsRequest | 
        String xRequestedWith = xRequestedWith_example; // String | CSRF/XHR sentinel header. Must be exactly "XMLHttpRequest" for browser-initiated unsafe requests.

        try {
            db_bulk_stats_200_response result = apiInstance.dbBulkStats(bulkDatabaseStatsRequest, xRequestedWith);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DatabaseApi#dbBulkStats");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
DatabaseApi *apiInstance = [[DatabaseApi alloc] init];
BulkDatabaseStatsRequest *bulkDatabaseStatsRequest = ; // 
String *xRequestedWith = xRequestedWith_example; // CSRF/XHR sentinel header. Must be exactly "XMLHttpRequest" for browser-initiated unsafe requests. (optional) (default to null)

// Get bulk database statistics
[apiInstance dbBulkStatsWith:bulkDatabaseStatsRequest
    xRequestedWith:xRequestedWith
              completionHandler: ^(db_bulk_stats_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.DatabaseApi()
var bulkDatabaseStatsRequest = ; // {BulkDatabaseStatsRequest} 
var opts = {
  'xRequestedWith': xRequestedWith_example // {String} CSRF/XHR sentinel header. Must be exactly "XMLHttpRequest" for browser-initiated unsafe requests.
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.dbBulkStats(bulkDatabaseStatsRequest, opts, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class dbBulkStatsExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new DatabaseApi();
            var bulkDatabaseStatsRequest = new BulkDatabaseStatsRequest(); // BulkDatabaseStatsRequest | 
            var xRequestedWith = xRequestedWith_example;  // String | CSRF/XHR sentinel header. Must be exactly "XMLHttpRequest" for browser-initiated unsafe requests. (optional)  (default to null)

            try {
                // Get bulk database statistics
                db_bulk_stats_200_response result = apiInstance.dbBulkStats(bulkDatabaseStatsRequest, xRequestedWith);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DatabaseApi.dbBulkStats: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DatabaseApi();
$bulkDatabaseStatsRequest = ; // BulkDatabaseStatsRequest | 
$xRequestedWith = xRequestedWith_example; // String | CSRF/XHR sentinel header. Must be exactly "XMLHttpRequest" for browser-initiated unsafe requests.

try {
    $result = $api_instance->dbBulkStats($bulkDatabaseStatsRequest, $xRequestedWith);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DatabaseApi->dbBulkStats: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DatabaseApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DatabaseApi->new();
my $bulkDatabaseStatsRequest = WWW::OPenAPIClient::Object::BulkDatabaseStatsRequest->new(); # BulkDatabaseStatsRequest | 
my $xRequestedWith = xRequestedWith_example; # String | CSRF/XHR sentinel header. Must be exactly "XMLHttpRequest" for browser-initiated unsafe requests.

eval {
    my $result = $api_instance->dbBulkStats(bulkDatabaseStatsRequest => $bulkDatabaseStatsRequest, xRequestedWith => $xRequestedWith);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DatabaseApi->dbBulkStats: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.DatabaseApi()
bulkDatabaseStatsRequest =  # BulkDatabaseStatsRequest | 
xRequestedWith = xRequestedWith_example # String | CSRF/XHR sentinel header. Must be exactly "XMLHttpRequest" for browser-initiated unsafe requests. (optional) (default to null)

try:
    # Get bulk database statistics
    api_response = api_instance.db_bulk_stats(bulkDatabaseStatsRequest, xRequestedWith=xRequestedWith)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DatabaseApi->dbBulkStats: %s\n" % e)

extern crate DatabaseApi;

pub fn main() {
    let bulkDatabaseStatsRequest = ; // BulkDatabaseStatsRequest
    let xRequestedWith = xRequestedWith_example; // String

    let mut context = DatabaseApi::Context::default();
    let result = client.dbBulkStats(bulkDatabaseStatsRequest, xRequestedWith, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.FeatureFlagsApi;

import java.io.File;
import java.util.*;

public class FeatureFlagsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        FeatureFlagsApi apiInstance = new FeatureFlagsApi();

        try {
            feature_flags_get_200_response result = apiInstance.featureFlagsGet();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FeatureFlagsApi#featureFlagsGet");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


try {
    final result = await api_instance.featureFlagsGet();
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->featureFlagsGet: $e\n');
}

import org.openapitools.client.api.FeatureFlagsApi;

public class FeatureFlagsApiExample {
    public static void main(String[] args) {
        FeatureFlagsApi apiInstance = new FeatureFlagsApi();

        try {
            feature_flags_get_200_response result = apiInstance.featureFlagsGet();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FeatureFlagsApi#featureFlagsGet");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
FeatureFlagsApi *apiInstance = [[FeatureFlagsApi alloc] init];

// Get feature flags
[apiInstance featureFlagsGetWithCompletionHandler: 
              ^(feature_flags_get_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.FeatureFlagsApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.featureFlagsGet(callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class featureFlagsGetExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new FeatureFlagsApi();

            try {
                // Get feature flags
                feature_flags_get_200_response result = apiInstance.featureFlagsGet();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling FeatureFlagsApi.featureFlagsGet: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\FeatureFlagsApi();

try {
    $result = $api_instance->featureFlagsGet();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling FeatureFlagsApi->featureFlagsGet: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::FeatureFlagsApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::FeatureFlagsApi->new();

eval {
    my $result = $api_instance->featureFlagsGet();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling FeatureFlagsApi->featureFlagsGet: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.FeatureFlagsApi()

try:
    # Get feature flags
    api_response = api_instance.feature_flags_get()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling FeatureFlagsApi->featureFlagsGet: %s\n" % e)

extern crate FeatureFlagsApi;

pub fn main() {

    let mut context = FeatureFlagsApi::Context::default();
    let result = client.featureFlagsGet(&context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.FeatureFlagsApi;

import java.io.File;
import java.util.*;

public class FeatureFlagsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        FeatureFlagsApi apiInstance = new FeatureFlagsApi();
        map[String, Boolean] requestBody = Object; // map[String, Boolean] | 

        try {
            feature_flags_get_200_response result = apiInstance.featureFlagsUpdate(requestBody);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FeatureFlagsApi#featureFlagsUpdate");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final map[String, Boolean] requestBody = new map[String, Boolean](); // map[String, Boolean] | 

try {
    final result = await api_instance.featureFlagsUpdate(requestBody);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->featureFlagsUpdate: $e\n');
}

import org.openapitools.client.api.FeatureFlagsApi;

public class FeatureFlagsApiExample {
    public static void main(String[] args) {
        FeatureFlagsApi apiInstance = new FeatureFlagsApi();
        map[String, Boolean] requestBody = Object; // map[String, Boolean] | 

        try {
            feature_flags_get_200_response result = apiInstance.featureFlagsUpdate(requestBody);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FeatureFlagsApi#featureFlagsUpdate");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
FeatureFlagsApi *apiInstance = [[FeatureFlagsApi alloc] init];
map[String, Boolean] *requestBody = Object; // 

// Update feature flags
[apiInstance featureFlagsUpdateWith:requestBody
              completionHandler: ^(feature_flags_get_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.FeatureFlagsApi()
var requestBody = Object; // {map[String, Boolean]} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.featureFlagsUpdate(requestBody, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class featureFlagsUpdateExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new FeatureFlagsApi();
            var requestBody = new map[String, Boolean](); // map[String, Boolean] | 

            try {
                // Update feature flags
                feature_flags_get_200_response result = apiInstance.featureFlagsUpdate(requestBody);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling FeatureFlagsApi.featureFlagsUpdate: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\FeatureFlagsApi();
$requestBody = Object; // map[String, Boolean] | 

try {
    $result = $api_instance->featureFlagsUpdate($requestBody);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling FeatureFlagsApi->featureFlagsUpdate: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::FeatureFlagsApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::FeatureFlagsApi->new();
my $requestBody = WWW::OPenAPIClient::Object::map[String, Boolean]->new(); # map[String, Boolean] | 

eval {
    my $result = $api_instance->featureFlagsUpdate(requestBody => $requestBody);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling FeatureFlagsApi->featureFlagsUpdate: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.FeatureFlagsApi()
requestBody = Object # map[String, Boolean] | 

try:
    # Update feature flags
    api_response = api_instance.feature_flags_update(requestBody)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling FeatureFlagsApi->featureFlagsUpdate: %s\n" % e)

extern crate FeatureFlagsApi;

pub fn main() {
    let requestBody = Object; // map[String, Boolean]

    let mut context = FeatureFlagsApi::Context::default();
    let result = client.featureFlagsUpdate(requestBody, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.HealthApi;

import java.io.File;
import java.util.*;

public class HealthApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        HealthApi apiInstance = new HealthApi();

        try {
            SuccessEnvelope result = apiInstance.healthCheck();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling HealthApi#healthCheck");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


try {
    final result = await api_instance.healthCheck();
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->healthCheck: $e\n');
}

import org.openapitools.client.api.HealthApi;

public class HealthApiExample {
    public static void main(String[] args) {
        HealthApi apiInstance = new HealthApi();

        try {
            SuccessEnvelope result = apiInstance.healthCheck();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling HealthApi#healthCheck");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
HealthApi *apiInstance = [[HealthApi alloc] init];

// Health check
[apiInstance healthCheckWithCompletionHandler: 
              ^(SuccessEnvelope output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.HealthApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.healthCheck(callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class healthCheckExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new HealthApi();

            try {
                // Health check
                SuccessEnvelope result = apiInstance.healthCheck();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling HealthApi.healthCheck: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\HealthApi();

try {
    $result = $api_instance->healthCheck();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling HealthApi->healthCheck: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::HealthApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::HealthApi->new();

eval {
    my $result = $api_instance->healthCheck();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling HealthApi->healthCheck: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.HealthApi()

try:
    # Health check
    api_response = api_instance.health_check()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling HealthApi->healthCheck: %s\n" % e)

extern crate HealthApi;

pub fn main() {

    let mut context = HealthApi::Context::default();
    let result = client.healthCheck(&context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.HealthApi;

import java.io.File;
import java.util.*;

public class HealthApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        HealthApi apiInstance = new HealthApi();

        try {
            SuccessEnvelope result = apiInstance.healthLive();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling HealthApi#healthLive");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


try {
    final result = await api_instance.healthLive();
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->healthLive: $e\n');
}

import org.openapitools.client.api.HealthApi;

public class HealthApiExample {
    public static void main(String[] args) {
        HealthApi apiInstance = new HealthApi();

        try {
            SuccessEnvelope result = apiInstance.healthLive();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling HealthApi#healthLive");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
HealthApi *apiInstance = [[HealthApi alloc] init];

// Liveness check
[apiInstance healthLiveWithCompletionHandler: 
              ^(SuccessEnvelope output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.HealthApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.healthLive(callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class healthLiveExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new HealthApi();

            try {
                // Liveness check
                SuccessEnvelope result = apiInstance.healthLive();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling HealthApi.healthLive: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\HealthApi();

try {
    $result = $api_instance->healthLive();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling HealthApi->healthLive: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::HealthApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::HealthApi->new();

eval {
    my $result = $api_instance->healthLive();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling HealthApi->healthLive: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.HealthApi()

try:
    # Liveness check
    api_response = api_instance.health_live()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling HealthApi->healthLive: %s\n" % e)

extern crate HealthApi;

pub fn main() {

    let mut context = HealthApi::Context::default();
    let result = client.healthLive(&context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.HealthApi;

import java.io.File;
import java.util.*;

public class HealthApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        HealthApi apiInstance = new HealthApi();

        try {
            SuccessEnvelope result = apiInstance.healthReady();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling HealthApi#healthReady");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


try {
    final result = await api_instance.healthReady();
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->healthReady: $e\n');
}

import org.openapitools.client.api.HealthApi;

public class HealthApiExample {
    public static void main(String[] args) {
        HealthApi apiInstance = new HealthApi();

        try {
            SuccessEnvelope result = apiInstance.healthReady();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling HealthApi#healthReady");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
HealthApi *apiInstance = [[HealthApi alloc] init];

// Readiness check
[apiInstance healthReadyWithCompletionHandler: 
              ^(SuccessEnvelope output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.HealthApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.healthReady(callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class healthReadyExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new HealthApi();

            try {
                // Readiness check
                SuccessEnvelope result = apiInstance.healthReady();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling HealthApi.healthReady: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\HealthApi();

try {
    $result = $api_instance->healthReady();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling HealthApi->healthReady: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::HealthApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::HealthApi->new();

eval {
    my $result = $api_instance->healthReady();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling HealthApi->healthReady: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.HealthApi()

try:
    # Readiness check
    api_response = api_instance.health_ready()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling HealthApi->healthReady: %s\n" % e)

extern crate HealthApi;

pub fn main() {

    let mut context = HealthApi::Context::default();
    let result = client.healthReady(&context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.HealthApi;

import java.io.File;
import java.util.*;

public class HealthApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        HealthApi apiInstance = new HealthApi();

        try {
            SuccessEnvelope result = apiInstance.ping();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling HealthApi#ping");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


try {
    final result = await api_instance.ping();
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->ping: $e\n');
}

import org.openapitools.client.api.HealthApi;

public class HealthApiExample {
    public static void main(String[] args) {
        HealthApi apiInstance = new HealthApi();

        try {
            SuccessEnvelope result = apiInstance.ping();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling HealthApi#ping");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
HealthApi *apiInstance = [[HealthApi alloc] init];

// Ping server
[apiInstance pingWithCompletionHandler: 
              ^(SuccessEnvelope output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.HealthApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.ping(callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class pingExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new HealthApi();

            try {
                // Ping server
                SuccessEnvelope result = apiInstance.ping();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling HealthApi.ping: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\HealthApi();

try {
    $result = $api_instance->ping();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling HealthApi->ping: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::HealthApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::HealthApi->new();

eval {
    my $result = $api_instance->ping();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling HealthApi->ping: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.HealthApi()

try:
    # Ping server
    api_response = api_instance.ping()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling HealthApi->ping: %s\n" % e)

extern crate HealthApi;

pub fn main() {

    let mut context = HealthApi::Context::default();
    let result = client.ping(&context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.KeywordExtractionApi;

import java.io.File;
import java.util.*;

public class KeywordExtractionApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        KeywordExtractionApi apiInstance = new KeywordExtractionApi();
        BatchKeywordExtractionRequest batchKeywordExtractionRequest = ; // BatchKeywordExtractionRequest | 

        try {
            keyword_extract_batch_200_response result = apiInstance.keywordExtractBatch(batchKeywordExtractionRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling KeywordExtractionApi#keywordExtractBatch");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final BatchKeywordExtractionRequest batchKeywordExtractionRequest = new BatchKeywordExtractionRequest(); // BatchKeywordExtractionRequest | 

try {
    final result = await api_instance.keywordExtractBatch(batchKeywordExtractionRequest);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->keywordExtractBatch: $e\n');
}

import org.openapitools.client.api.KeywordExtractionApi;

public class KeywordExtractionApiExample {
    public static void main(String[] args) {
        KeywordExtractionApi apiInstance = new KeywordExtractionApi();
        BatchKeywordExtractionRequest batchKeywordExtractionRequest = ; // BatchKeywordExtractionRequest | 

        try {
            keyword_extract_batch_200_response result = apiInstance.keywordExtractBatch(batchKeywordExtractionRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling KeywordExtractionApi#keywordExtractBatch");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
KeywordExtractionApi *apiInstance = [[KeywordExtractionApi alloc] init];
BatchKeywordExtractionRequest *batchKeywordExtractionRequest = ; // 

// Batch keyword extraction
[apiInstance keywordExtractBatchWith:batchKeywordExtractionRequest
              completionHandler: ^(keyword_extract_batch_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.KeywordExtractionApi()
var batchKeywordExtractionRequest = ; // {BatchKeywordExtractionRequest} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.keywordExtractBatch(batchKeywordExtractionRequest, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class keywordExtractBatchExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new KeywordExtractionApi();
            var batchKeywordExtractionRequest = new BatchKeywordExtractionRequest(); // BatchKeywordExtractionRequest | 

            try {
                // Batch keyword extraction
                keyword_extract_batch_200_response result = apiInstance.keywordExtractBatch(batchKeywordExtractionRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling KeywordExtractionApi.keywordExtractBatch: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\KeywordExtractionApi();
$batchKeywordExtractionRequest = ; // BatchKeywordExtractionRequest | 

try {
    $result = $api_instance->keywordExtractBatch($batchKeywordExtractionRequest);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling KeywordExtractionApi->keywordExtractBatch: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::KeywordExtractionApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::KeywordExtractionApi->new();
my $batchKeywordExtractionRequest = WWW::OPenAPIClient::Object::BatchKeywordExtractionRequest->new(); # BatchKeywordExtractionRequest | 

eval {
    my $result = $api_instance->keywordExtractBatch(batchKeywordExtractionRequest => $batchKeywordExtractionRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling KeywordExtractionApi->keywordExtractBatch: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.KeywordExtractionApi()
batchKeywordExtractionRequest =  # BatchKeywordExtractionRequest | 

try:
    # Batch keyword extraction
    api_response = api_instance.keyword_extract_batch(batchKeywordExtractionRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling KeywordExtractionApi->keywordExtractBatch: %s\n" % e)

extern crate KeywordExtractionApi;

pub fn main() {
    let batchKeywordExtractionRequest = ; // BatchKeywordExtractionRequest

    let mut context = KeywordExtractionApi::Context::default();
    let result = client.keywordExtractBatch(batchKeywordExtractionRequest, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.KeywordExtractionApi;

import java.io.File;
import java.util.*;

public class KeywordExtractionApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        KeywordExtractionApi apiInstance = new KeywordExtractionApi();
        URI url = url_example; // URI | 
        UUID keywordSetId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        UUID httpPersonaId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        UUID dnsPersonaId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            'String' result = apiInstance.keywordExtractStream(url, keywordSetId, httpPersonaId, dnsPersonaId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling KeywordExtractionApi#keywordExtractStream");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final URI url = new URI(); // URI | 
final UUID keywordSetId = new UUID(); // UUID | 
final UUID httpPersonaId = new UUID(); // UUID | 
final UUID dnsPersonaId = new UUID(); // UUID | 

try {
    final result = await api_instance.keywordExtractStream(url, keywordSetId, httpPersonaId, dnsPersonaId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->keywordExtractStream: $e\n');
}

import org.openapitools.client.api.KeywordExtractionApi;

public class KeywordExtractionApiExample {
    public static void main(String[] args) {
        KeywordExtractionApi apiInstance = new KeywordExtractionApi();
        URI url = url_example; // URI | 
        UUID keywordSetId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        UUID httpPersonaId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        UUID dnsPersonaId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            'String' result = apiInstance.keywordExtractStream(url, keywordSetId, httpPersonaId, dnsPersonaId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling KeywordExtractionApi#keywordExtractStream");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
KeywordExtractionApi *apiInstance = [[KeywordExtractionApi alloc] init];
URI *url = url_example; //  (default to null)
UUID *keywordSetId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (default to null)
UUID *httpPersonaId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (optional) (default to null)
UUID *dnsPersonaId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (optional) (default to null)

// Stream keyword extraction
[apiInstance keywordExtractStreamWith:url
    keywordSetId:keywordSetId
    httpPersonaId:httpPersonaId
    dnsPersonaId:dnsPersonaId
              completionHandler: ^('String' output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.KeywordExtractionApi()
var url = url_example; // {URI} 
var keywordSetId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} 
var opts = {
  'httpPersonaId': 38400000-8cf0-11bd-b23e-10b96e4ef00d, // {UUID} 
  'dnsPersonaId': 38400000-8cf0-11bd-b23e-10b96e4ef00d // {UUID} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.keywordExtractStream(url, keywordSetId, opts, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class keywordExtractStreamExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new KeywordExtractionApi();
            var url = url_example;  // URI |  (default to null)
            var keywordSetId = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (default to null)
            var httpPersonaId = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (optional)  (default to null)
            var dnsPersonaId = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (optional)  (default to null)

            try {
                // Stream keyword extraction
                'String' result = apiInstance.keywordExtractStream(url, keywordSetId, httpPersonaId, dnsPersonaId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling KeywordExtractionApi.keywordExtractStream: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\KeywordExtractionApi();
$url = url_example; // URI | 
$keywordSetId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
$httpPersonaId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
$dnsPersonaId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

try {
    $result = $api_instance->keywordExtractStream($url, $keywordSetId, $httpPersonaId, $dnsPersonaId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling KeywordExtractionApi->keywordExtractStream: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::KeywordExtractionApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::KeywordExtractionApi->new();
my $url = url_example; # URI | 
my $keywordSetId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 
my $httpPersonaId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 
my $dnsPersonaId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 

eval {
    my $result = $api_instance->keywordExtractStream(url => $url, keywordSetId => $keywordSetId, httpPersonaId => $httpPersonaId, dnsPersonaId => $dnsPersonaId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling KeywordExtractionApi->keywordExtractStream: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.KeywordExtractionApi()
url = url_example # URI |  (default to null)
keywordSetId = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (default to null)
httpPersonaId = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (optional) (default to null)
dnsPersonaId = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (optional) (default to null)

try:
    # Stream keyword extraction
    api_response = api_instance.keyword_extract_stream(url, keywordSetId, httpPersonaId=httpPersonaId, dnsPersonaId=dnsPersonaId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling KeywordExtractionApi->keywordExtractStream: %s\n" % e)

extern crate KeywordExtractionApi;

pub fn main() {
    let url = url_example; // URI
    let keywordSetId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID
    let httpPersonaId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID
    let dnsPersonaId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID

    let mut context = KeywordExtractionApi::Context::default();
    let result = client.keywordExtractStream(url, keywordSetId, httpPersonaId, dnsPersonaId, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.KeywordRulesApi;

import java.io.File;
import java.util.*;

public class KeywordRulesApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        KeywordRulesApi apiInstance = new KeywordRulesApi();
        Integer limit = 56; // Integer | 
        Integer offset = 56; // Integer | 
        UUID keywordSetId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        KeywordRuleType ruleType = ; // KeywordRuleType | 
        String category = category_example; // String | 
        Boolean isCaseSensitive = true; // Boolean | 
        String pattern = pattern_example; // String | 

        try {
            keyword_sets_rules_list_200_response result = apiInstance.keywordRulesQuery(limit, offset, keywordSetId, ruleType, category, isCaseSensitive, pattern);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling KeywordRulesApi#keywordRulesQuery");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Integer limit = new Integer(); // Integer | 
final Integer offset = new Integer(); // Integer | 
final UUID keywordSetId = new UUID(); // UUID | 
final KeywordRuleType ruleType = new KeywordRuleType(); // KeywordRuleType | 
final String category = new String(); // String | 
final Boolean isCaseSensitive = new Boolean(); // Boolean | 
final String pattern = new String(); // String | 

try {
    final result = await api_instance.keywordRulesQuery(limit, offset, keywordSetId, ruleType, category, isCaseSensitive, pattern);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->keywordRulesQuery: $e\n');
}

import org.openapitools.client.api.KeywordRulesApi;

public class KeywordRulesApiExample {
    public static void main(String[] args) {
        KeywordRulesApi apiInstance = new KeywordRulesApi();
        Integer limit = 56; // Integer | 
        Integer offset = 56; // Integer | 
        UUID keywordSetId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        KeywordRuleType ruleType = ; // KeywordRuleType | 
        String category = category_example; // String | 
        Boolean isCaseSensitive = true; // Boolean | 
        String pattern = pattern_example; // String | 

        try {
            keyword_sets_rules_list_200_response result = apiInstance.keywordRulesQuery(limit, offset, keywordSetId, ruleType, category, isCaseSensitive, pattern);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling KeywordRulesApi#keywordRulesQuery");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
KeywordRulesApi *apiInstance = [[KeywordRulesApi alloc] init];
Integer *limit = 56; //  (optional) (default to 50)
Integer *offset = 56; //  (optional) (default to 0)
UUID *keywordSetId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (optional) (default to null)
KeywordRuleType *ruleType = ; //  (optional) (default to null)
String *category = category_example; //  (optional) (default to null)
Boolean *isCaseSensitive = true; //  (optional) (default to null)
String *pattern = pattern_example; //  (optional) (default to null)

// Query keyword rules
[apiInstance keywordRulesQueryWith:limit
    offset:offset
    keywordSetId:keywordSetId
    ruleType:ruleType
    category:category
    isCaseSensitive:isCaseSensitive
    pattern:pattern
              completionHandler: ^(keyword_sets_rules_list_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.KeywordRulesApi()
var opts = {
  'limit': 56, // {Integer} 
  'offset': 56, // {Integer} 
  'keywordSetId': 38400000-8cf0-11bd-b23e-10b96e4ef00d, // {UUID} 
  'ruleType': , // {KeywordRuleType} 
  'category': category_example, // {String} 
  'isCaseSensitive': true, // {Boolean} 
  'pattern': pattern_example // {String} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.keywordRulesQuery(opts, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class keywordRulesQueryExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new KeywordRulesApi();
            var limit = 56;  // Integer |  (optional)  (default to 50)
            var offset = 56;  // Integer |  (optional)  (default to 0)
            var keywordSetId = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (optional)  (default to null)
            var ruleType = new KeywordRuleType(); // KeywordRuleType |  (optional)  (default to null)
            var category = category_example;  // String |  (optional)  (default to null)
            var isCaseSensitive = true;  // Boolean |  (optional)  (default to null)
            var pattern = pattern_example;  // String |  (optional)  (default to null)

            try {
                // Query keyword rules
                keyword_sets_rules_list_200_response result = apiInstance.keywordRulesQuery(limit, offset, keywordSetId, ruleType, category, isCaseSensitive, pattern);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling KeywordRulesApi.keywordRulesQuery: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\KeywordRulesApi();
$limit = 56; // Integer | 
$offset = 56; // Integer | 
$keywordSetId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
$ruleType = ; // KeywordRuleType | 
$category = category_example; // String | 
$isCaseSensitive = true; // Boolean | 
$pattern = pattern_example; // String | 

try {
    $result = $api_instance->keywordRulesQuery($limit, $offset, $keywordSetId, $ruleType, $category, $isCaseSensitive, $pattern);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling KeywordRulesApi->keywordRulesQuery: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::KeywordRulesApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::KeywordRulesApi->new();
my $limit = 56; # Integer | 
my $offset = 56; # Integer | 
my $keywordSetId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 
my $ruleType = ; # KeywordRuleType | 
my $category = category_example; # String | 
my $isCaseSensitive = true; # Boolean | 
my $pattern = pattern_example; # String | 

eval {
    my $result = $api_instance->keywordRulesQuery(limit => $limit, offset => $offset, keywordSetId => $keywordSetId, ruleType => $ruleType, category => $category, isCaseSensitive => $isCaseSensitive, pattern => $pattern);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling KeywordRulesApi->keywordRulesQuery: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.KeywordRulesApi()
limit = 56 # Integer |  (optional) (default to 50)
offset = 56 # Integer |  (optional) (default to 0)
keywordSetId = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (optional) (default to null)
ruleType =  # KeywordRuleType |  (optional) (default to null)
category = category_example # String |  (optional) (default to null)
isCaseSensitive = true # Boolean |  (optional) (default to null)
pattern = pattern_example # String |  (optional) (default to null)

try:
    # Query keyword rules
    api_response = api_instance.keyword_rules_query(limit=limit, offset=offset, keywordSetId=keywordSetId, ruleType=ruleType, category=category, isCaseSensitive=isCaseSensitive, pattern=pattern)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling KeywordRulesApi->keywordRulesQuery: %s\n" % e)

extern crate KeywordRulesApi;

pub fn main() {
    let limit = 56; // Integer
    let offset = 56; // Integer
    let keywordSetId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID
    let ruleType = ; // KeywordRuleType
    let category = category_example; // String
    let isCaseSensitive = true; // Boolean
    let pattern = pattern_example; // String

    let mut context = KeywordRulesApi::Context::default();
    let result = client.keywordRulesQuery(limit, offset, keywordSetId, ruleType, category, isCaseSensitive, pattern, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.KeywordSetsApi;

import java.io.File;
import java.util.*;

public class KeywordSetsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        KeywordSetsApi apiInstance = new KeywordSetsApi();
        CreateKeywordSetRequest createKeywordSetRequest = ; // CreateKeywordSetRequest | 

        try {
            keyword_sets_create_201_response result = apiInstance.keywordSetsCreate(createKeywordSetRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling KeywordSetsApi#keywordSetsCreate");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final CreateKeywordSetRequest createKeywordSetRequest = new CreateKeywordSetRequest(); // CreateKeywordSetRequest | 

try {
    final result = await api_instance.keywordSetsCreate(createKeywordSetRequest);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->keywordSetsCreate: $e\n');
}

import org.openapitools.client.api.KeywordSetsApi;

public class KeywordSetsApiExample {
    public static void main(String[] args) {
        KeywordSetsApi apiInstance = new KeywordSetsApi();
        CreateKeywordSetRequest createKeywordSetRequest = ; // CreateKeywordSetRequest | 

        try {
            keyword_sets_create_201_response result = apiInstance.keywordSetsCreate(createKeywordSetRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling KeywordSetsApi#keywordSetsCreate");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
KeywordSetsApi *apiInstance = [[KeywordSetsApi alloc] init];
CreateKeywordSetRequest *createKeywordSetRequest = ; // 

// Create keyword set
[apiInstance keywordSetsCreateWith:createKeywordSetRequest
              completionHandler: ^(keyword_sets_create_201_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.KeywordSetsApi()
var createKeywordSetRequest = ; // {CreateKeywordSetRequest} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.keywordSetsCreate(createKeywordSetRequest, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class keywordSetsCreateExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new KeywordSetsApi();
            var createKeywordSetRequest = new CreateKeywordSetRequest(); // CreateKeywordSetRequest | 

            try {
                // Create keyword set
                keyword_sets_create_201_response result = apiInstance.keywordSetsCreate(createKeywordSetRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling KeywordSetsApi.keywordSetsCreate: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\KeywordSetsApi();
$createKeywordSetRequest = ; // CreateKeywordSetRequest | 

try {
    $result = $api_instance->keywordSetsCreate($createKeywordSetRequest);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling KeywordSetsApi->keywordSetsCreate: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::KeywordSetsApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::KeywordSetsApi->new();
my $createKeywordSetRequest = WWW::OPenAPIClient::Object::CreateKeywordSetRequest->new(); # CreateKeywordSetRequest | 

eval {
    my $result = $api_instance->keywordSetsCreate(createKeywordSetRequest => $createKeywordSetRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling KeywordSetsApi->keywordSetsCreate: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.KeywordSetsApi()
createKeywordSetRequest =  # CreateKeywordSetRequest | 

try:
    # Create keyword set
    api_response = api_instance.keyword_sets_create(createKeywordSetRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling KeywordSetsApi->keywordSetsCreate: %s\n" % e)

extern crate KeywordSetsApi;

pub fn main() {
    let createKeywordSetRequest = ; // CreateKeywordSetRequest

    let mut context = KeywordSetsApi::Context::default();
    let result = client.keywordSetsCreate(createKeywordSetRequest, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.KeywordSetsApi;

import java.io.File;
import java.util.*;

public class KeywordSetsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        KeywordSetsApi apiInstance = new KeywordSetsApi();
        UUID setId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            apiInstance.keywordSetsDelete(setId);
        } catch (ApiException e) {
            System.err.println("Exception when calling KeywordSetsApi#keywordSetsDelete");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UUID setId = new UUID(); // UUID | 

try {
    final result = await api_instance.keywordSetsDelete(setId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->keywordSetsDelete: $e\n');
}

import org.openapitools.client.api.KeywordSetsApi;

public class KeywordSetsApiExample {
    public static void main(String[] args) {
        KeywordSetsApi apiInstance = new KeywordSetsApi();
        UUID setId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            apiInstance.keywordSetsDelete(setId);
        } catch (ApiException e) {
            System.err.println("Exception when calling KeywordSetsApi#keywordSetsDelete");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
KeywordSetsApi *apiInstance = [[KeywordSetsApi alloc] init];
UUID *setId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (default to null)

// Delete keyword set
[apiInstance keywordSetsDeleteWith:setId
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.KeywordSetsApi()
var setId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.keywordSetsDelete(setId, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class keywordSetsDeleteExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new KeywordSetsApi();
            var setId = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (default to null)

            try {
                // Delete keyword set
                apiInstance.keywordSetsDelete(setId);
            } catch (Exception e) {
                Debug.Print("Exception when calling KeywordSetsApi.keywordSetsDelete: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\KeywordSetsApi();
$setId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

try {
    $api_instance->keywordSetsDelete($setId);
} catch (Exception $e) {
    echo 'Exception when calling KeywordSetsApi->keywordSetsDelete: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::KeywordSetsApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::KeywordSetsApi->new();
my $setId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 

eval {
    $api_instance->keywordSetsDelete(setId => $setId);
};
if ($@) {
    warn "Exception when calling KeywordSetsApi->keywordSetsDelete: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.KeywordSetsApi()
setId = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (default to null)

try:
    # Delete keyword set
    api_instance.keyword_sets_delete(setId)
except ApiException as e:
    print("Exception when calling KeywordSetsApi->keywordSetsDelete: %s\n" % e)

extern crate KeywordSetsApi;

pub fn main() {
    let setId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID

    let mut context = KeywordSetsApi::Context::default();
    let result = client.keywordSetsDelete(setId, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.KeywordSetsApi;

import java.io.File;
import java.util.*;

public class KeywordSetsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        KeywordSetsApi apiInstance = new KeywordSetsApi();
        UUID setId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            keyword_sets_create_201_response result = apiInstance.keywordSetsGet(setId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling KeywordSetsApi#keywordSetsGet");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UUID setId = new UUID(); // UUID | 

try {
    final result = await api_instance.keywordSetsGet(setId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->keywordSetsGet: $e\n');
}

import org.openapitools.client.api.KeywordSetsApi;

public class KeywordSetsApiExample {
    public static void main(String[] args) {
        KeywordSetsApi apiInstance = new KeywordSetsApi();
        UUID setId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            keyword_sets_create_201_response result = apiInstance.keywordSetsGet(setId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling KeywordSetsApi#keywordSetsGet");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
KeywordSetsApi *apiInstance = [[KeywordSetsApi alloc] init];
UUID *setId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (default to null)

// Get keyword set
[apiInstance keywordSetsGetWith:setId
              completionHandler: ^(keyword_sets_create_201_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.KeywordSetsApi()
var setId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.keywordSetsGet(setId, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class keywordSetsGetExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new KeywordSetsApi();
            var setId = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (default to null)

            try {
                // Get keyword set
                keyword_sets_create_201_response result = apiInstance.keywordSetsGet(setId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling KeywordSetsApi.keywordSetsGet: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\KeywordSetsApi();
$setId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

try {
    $result = $api_instance->keywordSetsGet($setId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling KeywordSetsApi->keywordSetsGet: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::KeywordSetsApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::KeywordSetsApi->new();
my $setId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 

eval {
    my $result = $api_instance->keywordSetsGet(setId => $setId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling KeywordSetsApi->keywordSetsGet: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.KeywordSetsApi()
setId = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (default to null)

try:
    # Get keyword set
    api_response = api_instance.keyword_sets_get(setId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling KeywordSetsApi->keywordSetsGet: %s\n" % e)

extern crate KeywordSetsApi;

pub fn main() {
    let setId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID

    let mut context = KeywordSetsApi::Context::default();
    let result = client.keywordSetsGet(setId, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.KeywordSetsApi;

import java.io.File;
import java.util.*;

public class KeywordSetsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        KeywordSetsApi apiInstance = new KeywordSetsApi();
        Integer limit = 56; // Integer | Page size (items per page)
        Integer offset = 56; // Integer | Zero-based offset
        Boolean includeRules = true; // Boolean | If true, include rules array in keyword-sets list items
        Boolean isEnabled = true; // Boolean | Filter by enabled state

        try {
            keyword_sets_list_200_response result = apiInstance.keywordSetsList(limit, offset, includeRules, isEnabled);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling KeywordSetsApi#keywordSetsList");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Integer limit = new Integer(); // Integer | Page size (items per page)
final Integer offset = new Integer(); // Integer | Zero-based offset
final Boolean includeRules = new Boolean(); // Boolean | If true, include rules array in keyword-sets list items
final Boolean isEnabled = new Boolean(); // Boolean | Filter by enabled state

try {
    final result = await api_instance.keywordSetsList(limit, offset, includeRules, isEnabled);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->keywordSetsList: $e\n');
}

import org.openapitools.client.api.KeywordSetsApi;

public class KeywordSetsApiExample {
    public static void main(String[] args) {
        KeywordSetsApi apiInstance = new KeywordSetsApi();
        Integer limit = 56; // Integer | Page size (items per page)
        Integer offset = 56; // Integer | Zero-based offset
        Boolean includeRules = true; // Boolean | If true, include rules array in keyword-sets list items
        Boolean isEnabled = true; // Boolean | Filter by enabled state

        try {
            keyword_sets_list_200_response result = apiInstance.keywordSetsList(limit, offset, includeRules, isEnabled);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling KeywordSetsApi#keywordSetsList");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
KeywordSetsApi *apiInstance = [[KeywordSetsApi alloc] init];
Integer *limit = 56; // Page size (items per page) (optional) (default to 50)
Integer *offset = 56; // Zero-based offset (optional) (default to 0)
Boolean *includeRules = true; // If true, include rules array in keyword-sets list items (optional) (default to null)
Boolean *isEnabled = true; // Filter by enabled state (optional) (default to null)

// List keyword sets
[apiInstance keywordSetsListWith:limit
    offset:offset
    includeRules:includeRules
    isEnabled:isEnabled
              completionHandler: ^(keyword_sets_list_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.KeywordSetsApi()
var opts = {
  'limit': 56, // {Integer} Page size (items per page)
  'offset': 56, // {Integer} Zero-based offset
  'includeRules': true, // {Boolean} If true, include rules array in keyword-sets list items
  'isEnabled': true // {Boolean} Filter by enabled state
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.keywordSetsList(opts, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class keywordSetsListExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new KeywordSetsApi();
            var limit = 56;  // Integer | Page size (items per page) (optional)  (default to 50)
            var offset = 56;  // Integer | Zero-based offset (optional)  (default to 0)
            var includeRules = true;  // Boolean | If true, include rules array in keyword-sets list items (optional)  (default to null)
            var isEnabled = true;  // Boolean | Filter by enabled state (optional)  (default to null)

            try {
                // List keyword sets
                keyword_sets_list_200_response result = apiInstance.keywordSetsList(limit, offset, includeRules, isEnabled);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling KeywordSetsApi.keywordSetsList: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\KeywordSetsApi();
$limit = 56; // Integer | Page size (items per page)
$offset = 56; // Integer | Zero-based offset
$includeRules = true; // Boolean | If true, include rules array in keyword-sets list items
$isEnabled = true; // Boolean | Filter by enabled state

try {
    $result = $api_instance->keywordSetsList($limit, $offset, $includeRules, $isEnabled);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling KeywordSetsApi->keywordSetsList: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::KeywordSetsApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::KeywordSetsApi->new();
my $limit = 56; # Integer | Page size (items per page)
my $offset = 56; # Integer | Zero-based offset
my $includeRules = true; # Boolean | If true, include rules array in keyword-sets list items
my $isEnabled = true; # Boolean | Filter by enabled state

eval {
    my $result = $api_instance->keywordSetsList(limit => $limit, offset => $offset, includeRules => $includeRules, isEnabled => $isEnabled);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling KeywordSetsApi->keywordSetsList: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.KeywordSetsApi()
limit = 56 # Integer | Page size (items per page) (optional) (default to 50)
offset = 56 # Integer | Zero-based offset (optional) (default to 0)
includeRules = true # Boolean | If true, include rules array in keyword-sets list items (optional) (default to null)
isEnabled = true # Boolean | Filter by enabled state (optional) (default to null)

try:
    # List keyword sets
    api_response = api_instance.keyword_sets_list(limit=limit, offset=offset, includeRules=includeRules, isEnabled=isEnabled)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling KeywordSetsApi->keywordSetsList: %s\n" % e)

extern crate KeywordSetsApi;

pub fn main() {
    let limit = 56; // Integer
    let offset = 56; // Integer
    let includeRules = true; // Boolean
    let isEnabled = true; // Boolean

    let mut context = KeywordSetsApi::Context::default();
    let result = client.keywordSetsList(limit, offset, includeRules, isEnabled, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.KeywordSetsApi;

import java.io.File;
import java.util.*;

public class KeywordSetsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        KeywordSetsApi apiInstance = new KeywordSetsApi();
        UUID setId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            keyword_sets_rules_list_200_response result = apiInstance.keywordSetsRulesList(setId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling KeywordSetsApi#keywordSetsRulesList");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UUID setId = new UUID(); // UUID | 

try {
    final result = await api_instance.keywordSetsRulesList(setId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->keywordSetsRulesList: $e\n');
}

import org.openapitools.client.api.KeywordSetsApi;

public class KeywordSetsApiExample {
    public static void main(String[] args) {
        KeywordSetsApi apiInstance = new KeywordSetsApi();
        UUID setId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            keyword_sets_rules_list_200_response result = apiInstance.keywordSetsRulesList(setId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling KeywordSetsApi#keywordSetsRulesList");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
KeywordSetsApi *apiInstance = [[KeywordSetsApi alloc] init];
UUID *setId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (default to null)

// List rules for a keyword set
[apiInstance keywordSetsRulesListWith:setId
              completionHandler: ^(keyword_sets_rules_list_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.KeywordSetsApi()
var setId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.keywordSetsRulesList(setId, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class keywordSetsRulesListExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new KeywordSetsApi();
            var setId = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (default to null)

            try {
                // List rules for a keyword set
                keyword_sets_rules_list_200_response result = apiInstance.keywordSetsRulesList(setId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling KeywordSetsApi.keywordSetsRulesList: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\KeywordSetsApi();
$setId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

try {
    $result = $api_instance->keywordSetsRulesList($setId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling KeywordSetsApi->keywordSetsRulesList: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::KeywordSetsApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::KeywordSetsApi->new();
my $setId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 

eval {
    my $result = $api_instance->keywordSetsRulesList(setId => $setId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling KeywordSetsApi->keywordSetsRulesList: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.KeywordSetsApi()
setId = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (default to null)

try:
    # List rules for a keyword set
    api_response = api_instance.keyword_sets_rules_list(setId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling KeywordSetsApi->keywordSetsRulesList: %s\n" % e)

extern crate KeywordSetsApi;

pub fn main() {
    let setId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID

    let mut context = KeywordSetsApi::Context::default();
    let result = client.keywordSetsRulesList(setId, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.KeywordSetsApi;

import java.io.File;
import java.util.*;

public class KeywordSetsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        KeywordSetsApi apiInstance = new KeywordSetsApi();
        UUID setId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        UpdateKeywordSetRequest updateKeywordSetRequest = ; // UpdateKeywordSetRequest | 

        try {
            keyword_sets_create_201_response result = apiInstance.keywordSetsUpdate(setId, updateKeywordSetRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling KeywordSetsApi#keywordSetsUpdate");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UUID setId = new UUID(); // UUID | 
final UpdateKeywordSetRequest updateKeywordSetRequest = new UpdateKeywordSetRequest(); // UpdateKeywordSetRequest | 

try {
    final result = await api_instance.keywordSetsUpdate(setId, updateKeywordSetRequest);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->keywordSetsUpdate: $e\n');
}

import org.openapitools.client.api.KeywordSetsApi;

public class KeywordSetsApiExample {
    public static void main(String[] args) {
        KeywordSetsApi apiInstance = new KeywordSetsApi();
        UUID setId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        UpdateKeywordSetRequest updateKeywordSetRequest = ; // UpdateKeywordSetRequest | 

        try {
            keyword_sets_create_201_response result = apiInstance.keywordSetsUpdate(setId, updateKeywordSetRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling KeywordSetsApi#keywordSetsUpdate");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
KeywordSetsApi *apiInstance = [[KeywordSetsApi alloc] init];
UUID *setId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (default to null)
UpdateKeywordSetRequest *updateKeywordSetRequest = ; // 

// Update keyword set
[apiInstance keywordSetsUpdateWith:setId
    updateKeywordSetRequest:updateKeywordSetRequest
              completionHandler: ^(keyword_sets_create_201_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.KeywordSetsApi()
var setId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} 
var updateKeywordSetRequest = ; // {UpdateKeywordSetRequest} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.keywordSetsUpdate(setId, updateKeywordSetRequest, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class keywordSetsUpdateExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new KeywordSetsApi();
            var setId = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (default to null)
            var updateKeywordSetRequest = new UpdateKeywordSetRequest(); // UpdateKeywordSetRequest | 

            try {
                // Update keyword set
                keyword_sets_create_201_response result = apiInstance.keywordSetsUpdate(setId, updateKeywordSetRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling KeywordSetsApi.keywordSetsUpdate: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\KeywordSetsApi();
$setId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
$updateKeywordSetRequest = ; // UpdateKeywordSetRequest | 

try {
    $result = $api_instance->keywordSetsUpdate($setId, $updateKeywordSetRequest);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling KeywordSetsApi->keywordSetsUpdate: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::KeywordSetsApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::KeywordSetsApi->new();
my $setId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 
my $updateKeywordSetRequest = WWW::OPenAPIClient::Object::UpdateKeywordSetRequest->new(); # UpdateKeywordSetRequest | 

eval {
    my $result = $api_instance->keywordSetsUpdate(setId => $setId, updateKeywordSetRequest => $updateKeywordSetRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling KeywordSetsApi->keywordSetsUpdate: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.KeywordSetsApi()
setId = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (default to null)
updateKeywordSetRequest =  # UpdateKeywordSetRequest | 

try:
    # Update keyword set
    api_response = api_instance.keyword_sets_update(setId, updateKeywordSetRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling KeywordSetsApi->keywordSetsUpdate: %s\n" % e)

extern crate KeywordSetsApi;

pub fn main() {
    let setId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID
    let updateKeywordSetRequest = ; // UpdateKeywordSetRequest

    let mut context = KeywordSetsApi::Context::default();
    let result = client.keywordSetsUpdate(setId, updateKeywordSetRequest, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.MonitoringApi;

import java.io.File;
import java.util.*;

public class MonitoringApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        MonitoringApi apiInstance = new MonitoringApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            monitoring_performance_summary_200_response result = apiInstance.monitoringCampaignGeneric(campaignId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MonitoringApi#monitoringCampaignGeneric");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UUID campaignId = new UUID(); // UUID | 

try {
    final result = await api_instance.monitoringCampaignGeneric(campaignId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->monitoringCampaignGeneric: $e\n');
}

import org.openapitools.client.api.MonitoringApi;

public class MonitoringApiExample {
    public static void main(String[] args) {
        MonitoringApi apiInstance = new MonitoringApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            monitoring_performance_summary_200_response result = apiInstance.monitoringCampaignGeneric(campaignId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MonitoringApi#monitoringCampaignGeneric");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
MonitoringApi *apiInstance = [[MonitoringApi alloc] init];
UUID *campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (default to null)

// Monitoring campaign-specific endpoint
[apiInstance monitoringCampaignGenericWith:campaignId
              completionHandler: ^(monitoring_performance_summary_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.MonitoringApi()
var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.monitoringCampaignGeneric(campaignId, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class monitoringCampaignGenericExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new MonitoringApi();
            var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (default to null)

            try {
                // Monitoring campaign-specific endpoint
                monitoring_performance_summary_200_response result = apiInstance.monitoringCampaignGeneric(campaignId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling MonitoringApi.monitoringCampaignGeneric: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\MonitoringApi();
$campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

try {
    $result = $api_instance->monitoringCampaignGeneric($campaignId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling MonitoringApi->monitoringCampaignGeneric: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::MonitoringApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::MonitoringApi->new();
my $campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 

eval {
    my $result = $api_instance->monitoringCampaignGeneric(campaignId => $campaignId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling MonitoringApi->monitoringCampaignGeneric: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.MonitoringApi()
campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (default to null)

try:
    # Monitoring campaign-specific endpoint
    api_response = api_instance.monitoring_campaign_generic(campaignId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling MonitoringApi->monitoringCampaignGeneric: %s\n" % e)

extern crate MonitoringApi;

pub fn main() {
    let campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID

    let mut context = MonitoringApi::Context::default();
    let result = client.monitoringCampaignGeneric(campaignId, &context).wait();

    println!("{:?}", result);
}